This is the mail archive of the gcc-prs@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

c++/1796: gcc crash while compiling MICO (legal c++ code)



>Number:         1796
>Category:       c++
>Synopsis:       gcc crash while compiling MICO (legal c++ code)
>Confidential:   no
>Severity:       critical
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          ice-on-legal-code
>Submitter-Id:   net
>Arrival-Date:   Sat Jan 27 15:26:01 PST 2001
>Closed-Date:
>Last-Modified:
>Originator:     Karel Gardas
>Release:        2.97 20010127 (experimental)
>Organization:
>Environment:
System: Linux karel-nb 2.2.18 #1 Fri Jan 12 16:23:34 CET 2001 i686 unknown
Architecture: i686

	
host: i686-pc-linux-gnu
build: i686-pc-linux-gnu
target: i686-pc-linux-gnu
configured with: ../gcc/configure --prefix=/opt/gcc3/ --enable-threads=posix --enable-shared --enable-languages=c,c++,objc,f77,java
>Description:

    GCC c++ compiler crash while compiling mico:

c++  -I../include -O  -v -save-temps -fpermissive  -I/opt/mico-cvs//include -I/usr/local/include -DPIC -fPIC  -c orb_all.cc -o orb_all.pic.o
Reading specs from /opt/gcc3/bin/../lib/gcc-lib/i686-pc-linux-gnu/2.97/specs
Configured with: ../gcc/configure --prefix=/opt/gcc3/ --enable-threads=posix --enable-shared --enable-languages=c,c++,objc,f77,java
gcc version 2.97 20010127 (experimental)
 /opt/gcc3/bin/../lib/gcc-lib/i686-pc-linux-gnu/2.97/cpp0 -lang-c++ -D_GNU_SOURCE -D__GNUG__=2 -D__GXX_ABI_VERSION=100 -v -I../include -I/opt/mico-cvs//include -I/usr/local/include -iprefix /opt/gcc3/bin/../lib/gcc-lib/i686-pc-linux-gnu/2.97/ -D__GNUC__=2 -D__GNUC_MINOR__=97 -D__GNUC_PATCHLEVEL__=0 -D__ELF__ -Dunix -Dlinux -D__ELF__ -D__unix__ -D__linux__ -D__unix -D__linux -Asystem=posix -D__OPTIMIZE__ -D__STDC_HOSTED__=1 -Acpu=i386 -Amachine=i386 -Di386 -D__i386 -D__i386__ -D__tune_i686__ -D__tune_pentiumpro__ -D__PIC__ -D__pic__ -DPIC orb_all.cc orb_all.ii
GNU CPP version 2.97 20010127 (experimental) (cpplib) (i386 Linux/ELF)
ignoring duplicate directory "/opt/gcc3/include/g++-v3"
ignoring duplicate directory "/usr/local/include"
ignoring duplicate directory "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include"
ignoring duplicate directory "/opt/gcc3/i686-pc-linux-gnu/include"
#include "..." search starts here:
#include <...> search starts here:
 ../include
 /opt/mico-cvs/include
 /usr/local/include
 /opt/gcc3/include/g++-v3
 /opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include
 /opt/gcc3/i686-pc-linux-gnu/include
 /opt/gcc3/i686-pc-linux-gnu/include/g++-v3
 /usr/include
End of search list.
 /opt/gcc3/bin/../lib/gcc-lib/i686-pc-linux-gnu/2.97/cc1plus -fpreprocessed orb_all.ii -quiet -dumpbase orb_all.cc -O -version -fpermissive -fPIC -o orb_all.s
GNU CPP version 2.97 20010127 (experimental) (cpplib) (i386 Linux/ELF)
GNU C++ version 2.97 20010127 (experimental) (i686-pc-linux-gnu)
        compiled by GNU C version 2.97 20010127 (experimental).
In file included from orb_all.cc:8:
context.cc: In member function `void CORBA::Context::set_one_value(const char*, 
   const CORBA::Any&)':
context.cc:141: Internal compiler error in scan_region, at except.c:2804
Please submit a full bug report, with preprocessed source
if appropriate.  See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
make[1]: *** [orb_all.pic.o] Error 1
make[1]: Leaving directory `/home/kgardas/usr/src/cvs/mico/mico/orb'
make: *** [system] Error 1

>How-To-Repeat:

Required cpp output:


# 1 "orb_all.cc"
# 1 "../include/CORBA.h" 1
# 30 "../include/CORBA.h"
# 1 "../include/mico/assert.h" 1
# 27 "../include/mico/assert.h"
# 1 "/usr/include/stdlib.h" 1 3 4
# 25 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 250 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 251 "/usr/include/features.h" 2 3 4
# 278 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 279 "/usr/include/features.h" 2 3 4
# 26 "/usr/include/stdlib.h" 2 3 4







# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 199 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 3 4
typedef unsigned int size_t;
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {





typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;





__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
# 80 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw ();



extern double atof (__const char *__nptr) throw ();

extern int atoi (__const char *__nptr) throw ();

extern long int atol (__const char *__nptr) throw ();



__extension__ extern long long int atoll (__const char *__nptr) throw ();



extern double strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ();




extern float strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ();


extern long double strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ();




extern long int strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();


extern unsigned long int strtoul (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();





__extension__
extern long long int strtoq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();


__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();
# 132 "/usr/include/stdlib.h" 3 4
__extension__
extern long long int strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();


__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ();
# 157 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{
  struct locale_data *__locales[6];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;
} *__locale_t;
# 158 "/usr/include/stdlib.h" 2 3 4



extern long int __strtol_l (__const char *__restrict __nptr, char **__restrict __endptr, int __base, __locale_t __loc) throw ();



extern unsigned long int __strtoul_l (__const char *__restrict __nptr, char **__restrict __endptr, int __base, __locale_t __loc) throw ();



__extension__
extern long long int __strtoll_l (__const char *__restrict __nptr, char **__restrict __endptr, int __base, __locale_t __loc) throw ();



__extension__
extern unsigned long long int __strtoull_l (__const char *__restrict __nptr, char **__restrict __endptr, int __base, __locale_t __loc) throw ();





extern double __strtod_l (__const char *__restrict __nptr, char **__restrict __endptr, __locale_t __loc) throw ();


extern float __strtof_l (__const char *__restrict __nptr, char **__restrict __endptr, __locale_t __loc) throw ();


extern long double __strtold_l (__const char *__restrict __nptr, char **__restrict __endptr, __locale_t __loc) throw ();
# 196 "/usr/include/stdlib.h" 3 4
extern double __strtod_internal (__const char *__restrict __nptr, char **__restrict __endptr, int __group) throw ();


extern float __strtof_internal (__const char *__restrict __nptr, char **__restrict __endptr, int __group) throw ();

extern long double __strtold_internal (__const char * __restrict __nptr, char **__restrict __endptr, int __group) throw ();




extern long int __strtol_internal (__const char *__restrict __nptr, char **__restrict __endptr, int __base, int __group) throw ();





extern unsigned long int __strtoul_internal (__const char * __restrict __nptr, char **__restrict __endptr, int __base, int __group) throw ();







__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr, char **__restrict __endptr, int __base, int __group) throw ();





__extension__
extern unsigned long long int __strtoull_internal (__const char * __restrict __nptr, char ** __restrict __endptr, int __base, int __group) throw ();
# 242 "/usr/include/stdlib.h" 3 4
extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}


extern __inline float
strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtof_internal (__nptr, __endptr, 0);
}
extern __inline long double
strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtold_internal (__nptr, __endptr, 0);
}



__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr,
        int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}



__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr,
         int __base) throw ()
{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr,
          int __base) throw ()
{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}


extern __inline double
atof (__const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
extern __inline int
atoi (__const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline long int
atol (__const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}


__extension__ extern __inline long long int
atoll (__const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}
# 333 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw ();


extern long int a64l (__const char *__s) throw ();


# 1 "/usr/include/sys/types.h" 1 3 4
# 26 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/sys/types.h" 2 3 4

extern "C" {

# 1 "/usr/include/bits/types.h" 1 3 4
# 26 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/bits/types.h" 2 3 4


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 30 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;

__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef long long int __quad_t;
# 49 "/usr/include/bits/types.h" 3 4
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;

typedef __quad_t *__qaddr_t;

typedef __u_quad_t __dev_t;
typedef __u_int __uid_t;
typedef __u_int __gid_t;
typedef __u_long __ino_t;
typedef __u_int __mode_t;
typedef __u_int __nlink_t;
typedef long int __off_t;
typedef __quad_t __loff_t;
typedef int __pid_t;
typedef int __ssize_t;
typedef __u_long __rlim_t;
typedef __u_quad_t __rlim64_t;
typedef __u_int __id_t;

typedef struct
  {
    int __val[2];
  } __fsid_t;


typedef int __daddr_t;
typedef char *__caddr_t;
typedef long int __time_t;
typedef long int __swblk_t;

typedef long int __clock_t;


typedef unsigned long int __fd_mask;
# 100 "/usr/include/bits/types.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];





  } __fd_set;


typedef int __key_t;


typedef unsigned short int __ipc_pid_t;





typedef long int __blkcnt_t;
typedef __quad_t __blkcnt64_t;


typedef __u_long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;


typedef __u_long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;


typedef __u_long __ino64_t;


typedef __loff_t __off64_t;


typedef long int __t_scalar_t;
typedef unsigned long int __t_uscalar_t;


typedef int __intptr_t;




# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 68 "/usr/include/bits/sched.h" 3 4
struct __sched_param
  {
    int sched_priority;
  };
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4


struct _pthread_fastlock
{
  long int __status;
  int __spinlock;
};



typedef struct _pthread_descr_struct *_pthread_descr;





typedef struct
{
  int __detachstate;
  int __schedpolicy;
  struct __sched_param __schedparam;
  int __inheritsched;
  int __scope;
  size_t __guardsize;
  int __stackaddr_set;
  void *__stackaddr;
  size_t __stacksize;
} pthread_attr_t;



typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
} pthread_cond_t;



typedef struct
{
  int __dummy;
} pthread_condattr_t;


typedef unsigned int pthread_key_t;





typedef struct
{
  int __m_reserved;
  int __m_count;
  _pthread_descr __m_owner;
  int __m_kind;
  struct _pthread_fastlock __m_lock;
} pthread_mutex_t;



typedef struct
{
  int __mutexkind;
} pthread_mutexattr_t;



typedef int pthread_once_t;




typedef struct _pthread_rwlock_t
{
  struct _pthread_fastlock __rw_lock;
  int __rw_readers;
  _pthread_descr __rw_writer;
  _pthread_descr __rw_read_waiting;
  _pthread_descr __rw_write_waiting;
  int __rw_kind;
  int __rw_pshared;
} pthread_rwlock_t;



typedef struct
{
  int __lockkind;
  int __pshared;
} pthread_rwlockattr_t;




typedef unsigned long int pthread_t;
# 151 "/usr/include/bits/types.h" 2 3 4
# 31 "/usr/include/sys/types.h" 2 3 4


typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;


typedef __loff_t loff_t;



typedef __ino_t ino_t;






typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;





typedef __off_t off_t;






typedef __off64_t off64_t;




typedef __pid_t pid_t;




typedef __id_t id_t;



typedef __ssize_t ssize_t;




typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;



typedef __key_t key_t;






# 1 "/usr/include/time.h" 1 3 4
# 57 "/usr/include/time.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 58 "/usr/include/time.h" 2 3 4


typedef __clock_t clock_t;







# 1 "/usr/include/bits/types.h" 1 3 4
# 69 "/usr/include/time.h" 2 3 4


typedef __time_t time_t;
# 123 "/usr/include/sys/types.h" 2 3 4


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 126 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 169 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 191 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 22 "/usr/include/endian.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/endian.h" 2 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 36 "/usr/include/endian.h" 2 3 4
# 192 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/select.h" 1 3 4
# 25 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 26 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/types.h" 1 3 4
# 29 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/select.h" 1 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3 4



# 1 "/usr/include/time.h" 1 3 4
# 83 "/usr/include/time.h" 3 4
struct timespec
  {
    long int tv_sec;
    long int tv_nsec;
  };
# 39 "/usr/include/sys/select.h" 2 3 4

extern "C" {





struct timeval;

typedef __fd_mask fd_mask;


typedef __fd_set fd_set;
# 74 "/usr/include/sys/select.h" 3 4
extern int __select (int __nfds, __fd_set *__readfds, __fd_set *__writefds, __fd_set *__exceptfds, struct timeval *__timeout) throw ();


extern int select (int __nfds, __fd_set *__readfds, __fd_set *__writefds, __fd_set *__exceptfds, struct timeval *__timeout) throw ();
# 87 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, __fd_set *__readfds, __fd_set *__writefds, __fd_set *__exceptfds, const struct timespec *__timeout, const __sigset_t *__sigmask) throw ();





}
# 195 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 198 "/usr/include/sys/types.h" 2 3 4





typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;







typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;


}
# 340 "/usr/include/stdlib.h" 2 3 4






extern int32_t random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern void * initstate (unsigned int __seed, void * __statebuf, size_t __statelen) throw ();




extern void * setstate (void * __statebuf) throw ();







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf, int32_t *__restrict __result) throw ();


extern int srandom_r (unsigned int __seed, struct random_data *__buf) throw ();

extern int initstate_r (unsigned int __seed, void * __restrict __statebuf, size_t __statelen, struct random_data *__restrict __buf) throw ();




extern int setstate_r (void * __restrict __statebuf, struct random_data *__restrict __buf) throw ();






extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();



extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw ();


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3]) throw ();


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3]) throw ();


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3]) throw ();
extern void lcong48 (unsigned short int __param[7]) throw ();


struct drand48_data
  {
    unsigned short int x[3];
    unsigned short int a[3];
    unsigned short int c;
    unsigned short int old_x[3];
    int init;
  };



extern int drand48_r (struct drand48_data *__restrict __buffer, double *__restrict __result) throw ();

extern int erand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, double *__restrict __result) throw ();




extern int lrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) throw ();

extern int nrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) throw ();




extern int mrand48_r (struct drand48_data *__restrict __buffer, long int *__restrict __result) throw ();

extern int jrand48_r (unsigned short int __xsubi[3], struct drand48_data *__restrict __buffer, long int *__restrict __result) throw ();




extern int srand48_r (long int __seedval, struct drand48_data *__buffer) throw ();

extern int seed48_r (unsigned short int __seed16v[3], struct drand48_data *__buffer) throw ();


extern int lcong48_r (unsigned short int __param[7], struct drand48_data *__buffer) throw ();
# 474 "/usr/include/stdlib.h" 3 4
extern void * malloc (size_t __size) throw ();

extern void * calloc (size_t __nmemb, size_t __size) throw ();





extern void * realloc (void * __ptr, size_t __size) throw ();

extern void free (void * __ptr) throw ();



extern void cfree (void * __ptr) throw ();



# 1 "/usr/include/alloca.h" 1 3 4
# 22 "/usr/include/alloca.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/alloca.h" 2 3 4


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void * alloca (size_t __size) throw ();





}
# 493 "/usr/include/stdlib.h" 2 3 4




extern void * valloc (size_t __size) throw ();




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw ();




extern int __on_exit (void (*__func) (int __status, void * __arg), void * __arg) throw ();

extern int on_exit (void (*__func) (int __status, void * __arg), void * __arg) throw ();






extern void exit (int __status) throw () __attribute__ ((__noreturn__));




extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));




extern char *getenv (__const char *__name) throw ();



extern char *__secure_getenv (__const char *__name) throw ();





extern int putenv (char *__string) throw ();





extern int setenv (__const char *__name, __const char *__value, int __replace) throw ();



extern void unsetenv (__const char *__name) throw ();






extern int clearenv (void) throw ();
# 566 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw ();






extern int mkstemp (char *__template) throw ();




extern int system (__const char *__command) throw ();






extern char *canonicalize_file_name (__const char *__name) throw ();
# 595 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name, char *__restrict __resolved) throw ();







typedef int (*__compar_fn_t) (__const void *, __const void *);


typedef __compar_fn_t comparison_fn_t;





extern void * bsearch (__const void * __key, __const void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar);





extern void qsort (void * __base, size_t __nmemb, size_t __size, __compar_fn_t __compar);




extern int abs (int __x) throw () __attribute__ ((__const__));
extern long int labs (long int __x) throw () __attribute__ ((__const__));

__extension__ extern long long int llabs (long long int __x) throw ()
     __attribute__ ((__const__));






extern div_t div (int __numer, int __denom) throw () __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom) throw ()
     __attribute__ ((__const__));

__extension__ extern lldiv_t lldiv (long long int __numer, long long int __denom) throw ()

     __attribute__ ((__const__));
# 651 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw ();





extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw ();





extern char *gcvt (double __value, int __ndigit, char *__buf) throw ();


extern char *qecvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw ();

extern char *qfcvt (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign) throw ();

extern char *qgcvt (long double __value, int __ndigit, char *__buf) throw ();





extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw ();


extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw ();



extern int qecvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw ();


extern int qfcvt_r (long double __value, int __ndigit, int *__restrict __decpt, int *__restrict __sign, char *__restrict __buf, size_t __len) throw ();
# 695 "/usr/include/stdlib.h" 3 4
extern int mblen (__const char *__s, size_t __n) throw ();


extern int mbtowc (wchar_t *__restrict __pwc, __const char *__restrict __s, size_t __n) throw ();



extern int wctomb (char *__s, wchar_t __wchar) throw ();



extern size_t mbstowcs (wchar_t *__restrict __pwcs, __const char *__restrict __s, size_t __n) throw ();


extern size_t wcstombs (char *__restrict __s, __const wchar_t *__restrict __pwcs, size_t __n) throw ();
# 718 "/usr/include/stdlib.h" 3 4
extern int rpmatch (__const char *__response) throw ();
# 729 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp, __const char *__const *__restrict __tokens, char **__restrict __valuep) throw ();
# 738 "/usr/include/stdlib.h" 3 4
extern void setkey (__const char *__key) throw ();







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw ();






extern int ptsname_r (int __fd, char *__buf, size_t __buflen) throw ();


extern int getpt (void) throw ();





}
# 28 "../include/mico/assert.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 28 "/usr/include/stdio.h" 2 3 4

extern "C" {



# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4




# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 1 3 4
# 43 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 110 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 39 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 41 "/usr/include/stdio.h" 2 3 4







typedef struct _IO_FILE FILE;
# 57 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 30 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 9 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 10 "/usr/include/_G_config.h" 2 3 4




# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 312 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 35 "/usr/include/_G_config.h" 3 4
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 31 "/usr/include/libio.h" 2 3 4
# 48 "/usr/include/libio.h" 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 1 3 4
# 49 "/usr/include/libio.h" 2 3 4
# 154 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 164 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 187 "/usr/include/libio.h" 3 4
};

struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _blksize;
  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 233 "/usr/include/libio.h" 3 4
  __off64_t _offset;

  int _unused2[16];

};





struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 262 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void * __cookie, char *__buf, size_t __nbytes);
# 271 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_write_fn (void * __cookie, __const char *__buf, size_t __n);
# 280 "/usr/include/libio.h" 3 4
typedef int __io_seek_fn (void * __cookie, __off_t __pos, int __w);


typedef int __io_close_fn (void * __cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;


struct _IO_cookie_file
{
  struct _IO_FILE __file;
  const void *__vtable;
  void *__cookie;
  _IO_cookie_io_functions_t __io_functions;
};




extern "C" {


extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
# 337 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp) throw ();
extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();





extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 363 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, __gnuc_va_list, int *__restrict) throw ();

extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, __gnuc_va_list) throw ();

extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();

extern void _IO_free_backup_area (_IO_FILE *) throw ();


}
# 58 "/usr/include/stdio.h" 2 3 4



typedef __off_t fpos_t;




typedef __off64_t fpos64_t;
# 110 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 111 "/usr/include/stdio.h" 2 3 4



extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;







extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();




extern FILE *tmpfile (void) throw ();
# 140 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) throw ();


extern char *tmpnam (char *__s) throw ();




extern char *tmpnam_r (char *__s) throw ();
# 160 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx) throw ();




extern int fclose (FILE *__stream) throw ();

extern int fflush (FILE *__stream) throw ();



extern int fflush_unlocked (FILE *__stream) throw ();




extern int fcloseall (void) throw ();





extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) throw ();


extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) throw ();
# 203 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (__const char *__restrict __filename, __const char *__restrict __modes) throw ();

extern FILE *freopen64 (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) throw ();






extern FILE *fdopen (int __fd, __const char *__modes) throw ();





extern FILE *fopencookie (void *__restrict __magic_cookie, __const char *__restrict __modes, _IO_cookie_io_functions_t __io_funcs) throw ();






extern FILE *open_memstream (char **__restrict __bufloc, size_t *__restrict __sizeloc) throw ();






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, size_t __size) throw ();



extern void setlinebuf (FILE *__stream) throw ();




extern int fprintf (FILE *__restrict __stream, __const char *__restrict __format, ...) throw ();


extern int printf (__const char *__restrict __format, ...) throw ();

extern int sprintf (char *__restrict __s, __const char *__restrict __format, ...) throw ();



extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) throw ();



extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg) throw ();


extern int vsprintf (char *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen, __const char *__restrict __format, ...) throw ()

     __attribute__ ((__format__ (__printf__, 3, 4)));

extern int __vsnprintf (char *__restrict __s, size_t __maxlen, __const char *__restrict __format, __gnuc_va_list __arg) throw ()


     __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen, __const char *__restrict __format, __gnuc_va_list __arg) throw ()


     __attribute__ ((__format__ (__printf__, 3, 0)));





extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f, __gnuc_va_list __arg) throw ()

     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()

     __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()

     __attribute__ ((__format__ (__printf__, 2, 3)));


extern int vdprintf (int __fd, __const char *__restrict __fmt, __gnuc_va_list __arg) throw ()

     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...) throw ()
     __attribute__ ((__format__ (__printf__, 2, 3)));




extern int fscanf (FILE *__restrict __stream, __const char *__restrict __format, ...) throw ();


extern int scanf (__const char *__restrict __format, ...) throw ();

extern int sscanf (__const char *__restrict __s, __const char *__restrict __format, ...) throw ();




extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) throw ()


     __attribute__ ((__format__ (__scanf__, 2, 0)));


extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg) throw ()
     __attribute__ ((__format__ (__scanf__, 1, 0)));


extern int vsscanf (__const char *__restrict __s, __const char *__restrict __format, __gnuc_va_list __arg) throw ()


     __attribute__ ((__format__ (__scanf__, 2, 0)));




extern int fgetc (FILE *__stream) throw ();
extern int getc (FILE *__stream) throw ();


extern int getchar (void) throw ();







extern int getc_unlocked (FILE *__stream) throw ();
extern int getchar_unlocked (void) throw ();




extern int fgetc_unlocked (FILE *__stream) throw ();




extern int fputc (int __c, FILE *__stream) throw ();
extern int putc (int __c, FILE *__stream) throw ();


extern int putchar (int __c) throw ();







extern int fputc_unlocked (int __c, FILE *__stream) throw ();




extern int putc_unlocked (int __c, FILE *__stream) throw ();
extern int putchar_unlocked (int __c) throw ();





extern int getw (FILE *__stream) throw ();


extern int putw (int __w, FILE *__stream) throw ();




extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) throw ();




extern char *fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream) throw ();





extern char *gets (char *__s) throw ();
# 413 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) throw ();


extern __ssize_t getdelim (char **__restrict __lineptr, size_t *__restrict __n, int __delimiter, FILE *__restrict __stream) throw ();




extern __ssize_t getline (char **__restrict __lineptr, size_t *__restrict __n, FILE *__restrict __stream) throw ();






extern int fputs (__const char *__restrict __s, FILE *__restrict __stream) throw ();




extern int fputs_unlocked (__const char *__restrict __s, FILE *__restrict __stream) throw ();




extern int puts (__const char *__s) throw ();



extern int ungetc (int __c, FILE *__stream) throw ();



extern size_t fread (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) throw ();


extern size_t fwrite (__const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __s) throw ();




extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) throw ();

extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) throw ();






extern int fseek (FILE *__stream, long int __off, int __whence) throw ();

extern long int ftell (FILE *__stream) throw ();

extern void rewind (FILE *__stream) throw ();
# 493 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence) throw ();

extern __off_t ftello (FILE *__stream) throw ();



extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) throw ();


extern int fsetpos (FILE *__stream, __const fpos_t *__pos) throw ();
# 527 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) throw ();
extern __off64_t ftello64 (FILE *__stream) throw ();

extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos) throw ();

extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos) throw ();



extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw ();

extern int ferror (FILE *__stream) throw ();



extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw ();
extern int ferror_unlocked (FILE *__stream) throw ();




extern void perror (__const char *__s) throw ();




extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];





extern int fileno (FILE *__stream) throw ();




extern int fileno_unlocked (FILE *__stream) throw ();






extern FILE *popen (__const char *__command, __const char *__modes) throw ();


extern int pclose (FILE *__stream) throw ();





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s) throw ();




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack, __const char *__restrict __format, ...) throw ();

extern int obstack_vprintf (struct obstack *__restrict __obstack, __const char *__restrict __format, __gnuc_va_list __args) throw ();
# 614 "/usr/include/stdio.h" 3 4
extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw ();


extern void funlockfile (FILE *__stream) throw ();
# 635 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 32 "/usr/include/bits/stdio.h" 3 4
inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg) throw ()
{
  return vfprintf (stdout, __fmt, __arg);
}


inline int
getchar (void) throw ()
{
  return _IO_getc (stdin);
}




inline int
getc_unlocked (FILE *__fp) throw ()
{
  return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


inline int
getchar_unlocked (void) throw ()
{
  return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




inline int
putchar (int __c) throw ()
{
  return _IO_putc (__c, stdout);
}




inline int
fputc_unlocked (int __c, FILE *__stream) throw ()
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





inline int
putc_unlocked (int __c, FILE *__stream) throw ()
{
  return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


inline int
putchar_unlocked (int __c) throw ()
{
  return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream) throw ()
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





inline int
feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x10) != 0);
}


inline int
ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 636 "/usr/include/stdio.h" 2 3 4


}
# 29 "../include/mico/assert.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 35 "/usr/include/assert.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 36 "/usr/include/assert.h" 2 3 4
# 58 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (__const char *__assertion, __const char *__file, unsigned int __line, __const char *__function) throw ()



     __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, __const char *__file, unsigned int __line, __const char *__function) throw ()



     __attribute__ ((__noreturn__));

}
# 30 "../include/mico/assert.h" 2
# 38 "../include/mico/assert.h"
void mico_assert (const char *, int);
# 31 "../include/CORBA.h" 2
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 147 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 32 "../include/CORBA.h" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 33 "../include/CORBA.h" 2






# 1 "../include/mico/config.h" 1
# 40 "../include/CORBA.h" 2
# 131 "../include/CORBA.h"
# 1 "/opt/gcc3/include/g++-v3/string" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_string.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_string.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 34 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/os_defines.h" 1 3
# 43 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 44 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/os_defines.h" 2 3
# 35 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 2 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 1 3
# 17 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 18 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 1 3
# 47 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
# 1 "/opt/gcc3/include/g++-v3/new" 1 3
# 33 "/opt/gcc3/include/g++-v3/new" 3
#pragma interface "new"
# 1 "/opt/gcc3/include/g++-v3/cstddef" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 3
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 41 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 2 3

namespace std
{
  using ::ptrdiff_t;
  using ::size_t;
}
# 3 "/opt/gcc3/include/g++-v3/cstddef" 2 3
# 35 "/opt/gcc3/include/g++-v3/new" 2 3
# 1 "/opt/gcc3/include/g++-v3/exception" 1 3
# 34 "/opt/gcc3/include/g++-v3/exception" 3
#pragma interface "exception"

extern "C++" {

namespace std
{
  class exception
  {
  public:
    exception() throw() { }
    virtual ~exception() throw() { }
    virtual const char* what() const throw();
  };

  class bad_exception : public exception
  {
  public:
    bad_exception() throw() { }
    virtual ~bad_exception() throw() { }
  };

  typedef void (*terminate_handler) ();
  typedef void (*unexpected_handler) ();

  terminate_handler set_terminate(terminate_handler) throw();
  void terminate() __attribute__ ((__noreturn__));

  unexpected_handler set_unexpected(unexpected_handler) throw();
  void unexpected() __attribute__ ((__noreturn__));

  bool uncaught_exception() throw();
}

}
# 36 "/opt/gcc3/include/g++-v3/new" 2 3

extern "C++" {

namespace std {

  class bad_alloc : public exception {
  public:
    virtual const char* what() const throw() { return "bad_alloc"; }
  };

  struct nothrow_t {};
  extern const nothrow_t nothrow;
  typedef void (*new_handler)();
  new_handler set_new_handler (new_handler);

}


void *operator new (std::size_t) throw (std::bad_alloc);
void *operator new[] (std::size_t) throw (std::bad_alloc);
void operator delete (void *) throw();
void operator delete[] (void *) throw();
void *operator new (std::size_t, const std::nothrow_t&) throw();
void *operator new[] (std::size_t, const std::nothrow_t&) throw();
void operator delete (void *, const std::nothrow_t&) throw();
void operator delete[] (void *, const std::nothrow_t&) throw();


inline void *operator new(std::size_t, void *place) throw() { return place; }
inline void *operator new[](std::size_t, void *place) throw() { return place; }
}
# 48 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 2 3




# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 53 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 2 3


# 1 "/usr/include/stdlib.h" 1 3 4
# 44 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 2 3




namespace std
{
  using ::div_t;
  using ::ldiv_t;
# 65 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 3
  extern "C" double atof(const char*);
  extern "C" int atoi(const char*);
  extern "C" long int atol(const char*);
  extern "C" double strtod(const char*, char**);
  extern "C" float strtof(const char*, char**);
  extern "C" long int strtol(const char*, char**, int);
  extern "C" unsigned long int strtoul(const char*, char**, int);
  extern "C" int rand(void);
  extern "C" void srand(unsigned int);
  extern "C" void* calloc(size_t, size_t);
  extern "C" void free(void*);
  extern "C" void* malloc(size_t);
  extern "C" void* realloc(void*, size_t);
  extern "C" void abort(void);
  extern "C" int atexit(void (*func)(void));
  extern "C" void exit(int);
  extern "C" void _Exit(int);
  extern "C" char*getenv(const char*);
  extern "C" int system(const char*);
  extern "C" void* bsearch(const void*, const void*, size_t, size_t,
                           int (*comp)(const void *, const void *));
  extern "C" void qsort(void*, size_t, size_t,
                        int (*comp)(const void *, const void *));
  extern "C" int abs(int);
  extern "C" long int labs(long int);
  extern "C" div_t div(int, int);
  extern "C" ldiv_t ldiv(long int, long int);
  extern "C" int mblen(const char*, size_t);
  extern "C" int mbtowc(wchar_t*, const char*, size_t);
  extern "C" int wctomb(char*, wchar_t);
  extern "C" size_t mbstowcs(wchar_t*, const char*, size_t);
  extern "C" size_t wcstombs(char*, const wchar_t*, size_t);
# 119 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 3
  extern "C" long double strtold(const char*, char**);

}
# 54 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 2 3


# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 34 "/usr/include/string.h" 2 3 4



extern void * memcpy (void * __restrict __dest, __const void * __restrict __src, size_t __n) throw ();



extern void * memmove (void * __dest, __const void * __src, size_t __n) throw ();






extern void * memccpy (void * __dest, __const void * __src, int __c, size_t __n) throw ();





extern void * memset (void * __s, int __c, size_t __n) throw ();


extern int memcmp (__const void * __s1, __const void * __s2, size_t __n) throw ();



extern void * memchr (__const void * __s, int __c, size_t __n) throw ();




extern void * rawmemchr (__const void * __s, int __c) throw ();




extern char *strcpy (char *__restrict __dest, __const char *__restrict __src) throw ();


extern char *strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __n) throw ();



extern char *strcat (char *__restrict __dest, __const char *__restrict __src) throw ();


extern char *strncat (char *__restrict __dest, __const char *__restrict __src, size_t __n) throw ();



extern int strcmp (__const char *__s1, __const char *__s2) throw ();

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n) throw ();


extern int strcoll (__const char *__s1, __const char *__s2) throw ();

extern size_t strxfrm (char *__restrict __dest, __const char *__restrict __src, size_t __n) throw ();






# 1 "/usr/include/xlocale.h" 1 3 4
# 100 "/usr/include/string.h" 2 3 4


extern int __strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l) throw ();


extern size_t __strxfrm_l (char *__dest, __const char *__src, size_t __n, __locale_t __l) throw ();





extern char *__strdup (__const char *__s) throw ();
extern char *strdup (__const char *__s) throw ();






extern char *strndup (__const char *__string, size_t __n) throw ();
# 146 "/usr/include/string.h" 3 4
extern char *strchr (__const char *__s, int __c) throw ();

extern char *strrchr (__const char *__s, int __c) throw ();




extern char *strchrnul (__const char *__s, int __c) throw ();




extern size_t strcspn (__const char *__s, __const char *__reject) throw ();


extern size_t strspn (__const char *__s, __const char *__accept) throw ();

extern char *strpbrk (__const char *__s, __const char *__accept) throw ();

extern char *strstr (__const char *__haystack, __const char *__needle) throw ();



extern char *__strcasestr (__const char *__haystack, __const char *__needle) throw ();

extern char *strcasestr (__const char *__haystack, __const char *__needle) throw ();




extern char *strtok (char *__restrict __s, __const char *__restrict __delim) throw ();




extern char *__strtok_r (char *__restrict __s, __const char *__restrict __delim, char **__restrict __save_ptr) throw ();



extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim, char **__restrict __save_ptr) throw ();
# 194 "/usr/include/string.h" 3 4
extern void * memmem (__const void * __haystack, size_t __haystacklen, __const void * __needle, size_t __needlelen) throw ();




extern void * __mempcpy (void * __restrict __dest, __const void * __restrict __src, size_t __n) throw ();

extern void * mempcpy (void * __restrict __dest, __const void * __restrict __src, size_t __n) throw ();





extern size_t strlen (__const char *__s) throw ();




extern size_t strnlen (__const char *__string, size_t __maxlen) throw ();




extern char *strerror (int __errnum) throw ();



extern char *__strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();




extern void __bzero (void * __s, size_t __n) throw ();



extern void bcopy (__const void * __src, void * __dest, size_t __n) throw ();


extern void bzero (void * __s, size_t __n) throw ();


extern int bcmp (__const void * __s1, __const void * __s2, size_t __n) throw ();


extern char *index (__const char *__s, int __c) throw ();


extern char *rindex (__const char *__s, int __c) throw ();



extern int __ffs (int __i) throw () __attribute__ ((const));
extern int ffs (int __i) throw () __attribute__ ((const));




extern int ffsl (long int __l) throw () __attribute__ ((const));

__extension__ extern int ffsll (long long int __ll) throw ()
     __attribute__ ((const));




extern int __strcasecmp (__const char *__s1, __const char *__s2) throw ();
extern int strcasecmp (__const char *__s1, __const char *__s2) throw ();


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n) throw ();






extern int __strcasecmp_l (__const char *__s1, __const char *__s2, __locale_t __loc) throw ();


extern int __strncasecmp_l (__const char *__s1, __const char *__s2, size_t __n, __locale_t __loc) throw ();






extern char *strsep (char **__restrict __stringp, __const char *__restrict __delim) throw ();





extern int strverscmp (__const char *__s1, __const char *__s2) throw ();


extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src) throw ();

extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src) throw ();




extern char *__stpncpy (char *__restrict __dest, __const char *__restrict __src, size_t __n) throw ();

extern char *stpncpy (char *__restrict __dest, __const char *__restrict __src, size_t __n) throw ();



extern char *strfry (char *__string) throw ();


extern void * memfrob (void * __s, size_t __n) throw ();






extern char *basename (__const char *__filename) throw ();
# 350 "/usr/include/string.h" 3 4
}
# 44 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 2 3

namespace std
{
  extern "C" void* memcpy(void*, const void*, size_t);
  extern "C" void* memmove(void*, const void*, size_t);
  extern "C" char* strcpy(char*, const char*);
  extern "C" char* strncpy(char*, const char*, size_t);
  extern "C" char* strcat(char*, const char*);
  extern "C" char* strncat(char*, const char*, size_t);
  extern "C" int memcmp(const void*, const void*, size_t);
  extern "C" int strcmp(const char*, const char*);
  extern "C" int strcoll(const char*, const char*);
  extern "C" int strncmp(const char*, const char*, size_t);
  extern "C" size_t strxfrm(char*, const char*, size_t);
  extern "C" void* memchr(const void*, int, size_t);
  extern "C" char* strchr(const char*, int);
  extern "C" size_t strcspn(const char*, const char*);
  extern "C" char* strpbrk(const char*, const char*);
  extern "C" char* strrchr(const char*, int);
  extern "C" size_t strspn(const char*, const char*);
  extern "C" char* strstr(const char*, const char*);
  extern "C" char* strtok(char*, const char*);
  extern "C" void* memset(void*, int, size_t);
  extern "C" char* strerror(int);
  extern "C" size_t strlen(const char*);
}
# 55 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cassert.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cassert.h" 3
# 1 "/usr/include/assert.h" 1 3 4
# 35 "/usr/include/assert.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 36 "/usr/include/assert.h" 2 3 4
# 58 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (__const char *__assertion, __const char *__file, unsigned int __line, __const char *__function) throw ()



     __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, __const char *__file, unsigned int __line, __const char *__function) throw ()



     __attribute__ ((__noreturn__));

}
# 40 "/opt/gcc3/include/g++-v3/bits/std_cassert.h" 2 3
# 56 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 2 3
# 91 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
namespace std {
# 108 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <int __inst>
class __malloc_alloc_template {

private:

  static void* _S_oom_malloc(size_t);
  static void* _S_oom_realloc(void*, size_t);


  static void (* __malloc_alloc_oom_handler)();


public:

  static void* allocate(size_t __n)
  {
    void* __result = malloc(__n);
    if (0 == __result) __result = _S_oom_malloc(__n);
    return __result;
  }

  static void deallocate(void* __p, size_t )
  {
    free(__p);
  }

  static void* reallocate(void* __p, size_t , size_t __new_sz)
  {
    void* __result = realloc(__p, __new_sz);
    if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
    return __result;
  }

  static void (* __set_malloc_handler(void (*__f)()))()
  {
    void (* __old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = __f;
    return(__old);
  }

};




template <int __inst>
void (* __malloc_alloc_template<__inst>::__malloc_alloc_oom_handler)() = 0;


template <int __inst>
void*
__malloc_alloc_template<__inst>::_S_oom_malloc(size_t __n)
{
    void (* __my_malloc_handler)();
    void* __result;

    for (;;) {
        __my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == __my_malloc_handler) { throw std::bad_alloc(); }
        (*__my_malloc_handler)();
        __result = malloc(__n);
        if (__result) return(__result);
    }
}

template <int __inst>
void* __malloc_alloc_template<__inst>::_S_oom_realloc(void* __p, size_t __n)
{
    void (* __my_malloc_handler)();
    void* __result;

    for (;;) {
        __my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == __my_malloc_handler) { throw std::bad_alloc(); }
        (*__my_malloc_handler)();
        __result = realloc(__p, __n);
        if (__result) return(__result);
    }
}

typedef __malloc_alloc_template<0> malloc_alloc;

template<class _Tp, class _Alloc>
class simple_alloc {

public:
    static _Tp* allocate(size_t __n)
      { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
    static _Tp* allocate(void)
      { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
    static void deallocate(_Tp* __p, size_t __n)
      { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
    static void deallocate(_Tp* __p)
      { _Alloc::deallocate(__p, sizeof (_Tp)); }
};






template <class _Alloc>
class debug_alloc {

private:

  enum {_S_extra = 8};



public:

  static void* allocate(size_t __n)
  {
    char* __result = (char*)_Alloc::allocate(__n + (int) _S_extra);
    *(size_t*)__result = __n;
    return __result + (int) _S_extra;
  }

  static void deallocate(void* __p, size_t __n)
  {
    char* __real_p = (char*)__p - (int) _S_extra;
    ((void) ((*(size_t*)__real_p == __n) ? 0 : (__assert_fail ("*(size_t*)__real_p == __n", "/opt/gcc3/include/g++-v3/bits/stl_alloc.h", 230, __PRETTY_FUNCTION__), 0)));
    _Alloc::deallocate(__real_p, __n + (int) _S_extra);
  }

  static void* reallocate(void* __p, size_t __old_sz, size_t __new_sz)
  {
    char* __real_p = (char*)__p - (int) _S_extra;
    ((void) ((*(size_t*)__real_p == __old_sz) ? 0 : (__assert_fail ("*(size_t*)__real_p == __old_sz", "/opt/gcc3/include/g++-v3/bits/stl_alloc.h", 237, __PRETTY_FUNCTION__), 0)));
    char* __result = (char*)
      _Alloc::reallocate(__real_p, __old_sz + (int) _S_extra,
                                   __new_sz + (int) _S_extra);
    *(size_t*)__result = __new_sz;
    return __result + (int) _S_extra;
  }

};




typedef malloc_alloc alloc;
typedef malloc_alloc single_client_alloc;
# 588 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp>
class allocator {
  typedef alloc _Alloc;
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp* pointer;
  typedef const _Tp* const_pointer;
  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() throw() {}
  allocator(const allocator&) throw() {}
  template <class _Tp1> allocator(const allocator<_Tp1>&) throw() {}
  ~allocator() throw() {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }



  _Tp* allocate(size_type __n, const void* = 0) {
    return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)))
                    : 0;
  }


  void deallocate(pointer __p, size_type __n)
    { _Alloc::deallocate(__p, __n * sizeof(_Tp)); }

  size_type max_size() const throw()
    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
  void destroy(pointer __p) { __p->~_Tp(); }
};

template<>
class allocator<void> {
public:
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };
};


template <class _T1, class _T2>
inline bool operator==(const allocator<_T1>&, const allocator<_T2>&)
{
  return true;
}

template <class _T1, class _T2>
inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&)
{
  return false;
}
# 664 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Alloc>
struct __allocator {
  _Alloc __underlying_alloc;

  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp* pointer;
  typedef const _Tp* const_pointer;
  typedef _Tp& reference;
  typedef const _Tp& const_reference;
  typedef _Tp value_type;

  template <class _Tp1> struct rebind {
    typedef __allocator<_Tp1, _Alloc> other;
  };

  __allocator() throw() {}
  __allocator(const __allocator& __a) throw()
    : __underlying_alloc(__a.__underlying_alloc) {}
  template <class _Tp1>
  __allocator(const __allocator<_Tp1, _Alloc>& __a) throw()
    : __underlying_alloc(__a.__underlying_alloc) {}
  ~__allocator() throw() {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }


  _Tp* allocate(size_type __n, const void* = 0) {
    return __n != 0
        ? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp)))
        : 0;
  }


  void deallocate(pointer __p, size_type __n)
    { __underlying_alloc.deallocate(__p, __n * sizeof(_Tp)); }

  size_type max_size() const throw()
    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }
  void destroy(pointer __p) { __p->~_Tp(); }
};

template <class _Alloc>
class __allocator<void, _Alloc> {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;

  template <class _Tp1> struct rebind {
    typedef __allocator<_Tp1, _Alloc> other;
  };
};

template <class _Tp, class _Alloc>
inline bool operator==(const __allocator<_Tp, _Alloc>& __a1,
                       const __allocator<_Tp, _Alloc>& __a2)
{
  return __a1.__underlying_alloc == __a2.__underlying_alloc;
}


template <class _Tp, class _Alloc>
inline bool operator!=(const __allocator<_Tp, _Alloc>& __a1,
                       const __allocator<_Tp, _Alloc>& __a2)
{
  return __a1.__underlying_alloc != __a2.__underlying_alloc;
}






template <int inst>
inline bool operator==(const __malloc_alloc_template<inst>&,
                       const __malloc_alloc_template<inst>&)
{
  return true;
}


template <int __inst>
inline bool operator!=(const __malloc_alloc_template<__inst>&,
                       const __malloc_alloc_template<__inst>&)
{
  return false;
}


template <class _Alloc>
inline bool operator==(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return true;
}


template <class _Alloc>
inline bool operator!=(const debug_alloc<_Alloc>&,
                       const debug_alloc<_Alloc>&) {
  return false;
}
# 800 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Allocator>
struct _Alloc_traits
{
  static const bool _S_instanceless = false;
  typedef typename _Allocator:: rebind<_Tp>::other
          allocator_type;
};

template <class _Tp, class _Allocator>
const bool _Alloc_traits<_Tp, _Allocator>::_S_instanceless;



template <class _Tp, class _Tp1>
struct _Alloc_traits<_Tp, allocator<_Tp1> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, alloc> _Alloc_type;
  typedef allocator<_Tp> allocator_type;
};



template <class _Tp, int __inst>
struct _Alloc_traits<_Tp, __malloc_alloc_template<__inst> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};
# 843 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Alloc>
struct _Alloc_traits<_Tp, debug_alloc<_Alloc> >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};




template <class _Tp, class _Tp1, int __inst>
struct _Alloc_traits<_Tp,
                     __allocator<_Tp1, __malloc_alloc_template<__inst> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, __malloc_alloc_template<__inst> > _Alloc_type;
  typedef __allocator<_Tp, __malloc_alloc_template<__inst> > allocator_type;
};
# 877 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
template <class _Tp, class _Tp1, class _Alloc>
struct _Alloc_traits<_Tp, __allocator<_Tp1, debug_alloc<_Alloc> > >
{
  static const bool _S_instanceless = true;
  typedef simple_alloc<_Tp, debug_alloc<_Alloc> > _Alloc_type;
  typedef __allocator<_Tp, debug_alloc<_Alloc> > allocator_type;
};
# 892 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 3
}
# 19 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdarg.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cstdarg.h" 3
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 1 3 4
# 41 "/opt/gcc3/include/g++-v3/bits/std_cstdarg.h" 2 3

namespace std
{
  using ::va_list;
}
# 41 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 2 3


# 1 "/usr/include/stdio.h" 1 3 4
# 45 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 2 3
# 57 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 3
namespace std
{
  using ::FILE;
  using ::fpos_t;

  extern "C" int remove(const char*);
  extern "C" int rename(const char*, const char*);
  extern "C" FILE* tmpfile(void);
  extern "C" char* tmpnam(char*);
  extern "C" int fclose(FILE*);
  extern "C" int fflush(FILE*);
  extern "C" FILE* fopen(const char*, const char*);
  extern "C" FILE* freopen(const char*, const char*, FILE*);
  extern "C" void setbuf(FILE*, char*);
  extern "C" int setvbuf(FILE*, char*, int, size_t);
  extern "C" int fprintf(FILE*, const char*, ...);
  extern "C" int fscanf(FILE*, const char*, ...);
  extern "C" int printf(const char*, ...);
  extern "C" int scanf(const char*, ...);
  extern "C" int snprintf(char *, size_t, const char*, ...);
  extern "C" int sprintf(char *, const char*, ...);
  extern "C" int sscanf(const char*, const char*, ...);
  extern "C" int vfprintf(FILE*, const char*, va_list);
  extern "C" int vfscanf(FILE*, const char*, va_list);
  extern "C" int vprintf(const char*, va_list);
  extern "C" int vscanf(const char*, va_list);
  extern "C" int vsnprintf(char*, size_t, const char*, va_list);
  extern "C" int vsprintf(char*, const char*, va_list);
  extern "C" int vsscanf(const char*, const char*, va_list);
  extern "C" int fgetc(FILE *);
  extern "C" char *fgets(char*, int, FILE*);
  extern "C" int fputc(int, FILE*);
  extern "C" int fputs(const char*, FILE*);
  extern "C" int getc(FILE*);
  extern "C" int getchar(void);
  extern "C" char *gets(char*);
  extern "C" int putc(int, FILE*);
  extern "C" int putchar(int);
  extern "C" int puts(const char*);
  extern "C" int ungetc(int, FILE*);
  extern "C" size_t fread(void*, size_t, size_t, FILE*);
  extern "C" size_t fwrite(const void*, size_t, size_t, FILE*);
  extern "C" int fgetpos(FILE*, fpos_t*);
  extern "C" int fseek(FILE*, long int, int);
  extern "C" int fsetpos(FILE*, const fpos_t*);
  extern "C" long int ftell(FILE*);
  extern "C" void rewind(FILE*);
  extern "C" void clearerr(FILE*);
  extern "C" int feof(FILE*);
  extern "C" int ferror(FILE*);
  extern "C" void perror(const char*);
}
# 42 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdarg.h" 1 3
# 43 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 2 3



# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 28 "/usr/include/wchar.h" 2 3 4



# 1 "/usr/include/stdio.h" 1 3 4
# 32 "/usr/include/wchar.h" 2 3 4






# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 39 "/usr/include/wchar.h" 2 3 4
# 53 "/usr/include/wchar.h" 3 4
typedef struct
{
  int count;
  wint_t value;
} mbstate_t;
# 77 "/usr/include/wchar.h" 3 4
struct tm;


extern "C" {


extern wchar_t *wcscpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw ();


extern wchar_t *wcsncpy (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw ();



extern wchar_t *wcscat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw ();


extern wchar_t *wcsncat (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw ();



extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();

extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw ();




extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();


extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw ();




# 1 "/usr/include/xlocale.h" 1 3 4
# 113 "/usr/include/wchar.h" 2 3 4

extern int __wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, __locale_t __loc) throw ();


extern int __wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n, __locale_t __loc) throw ();





extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();



extern size_t wcsxfrm (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ();
# 136 "/usr/include/wchar.h" 3 4
extern int __wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2, __locale_t __loc) throw ();




extern size_t __wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2, size_t __n, __locale_t __loc) throw ();



extern wchar_t *wcsdup (__const wchar_t *__s) throw ();



extern wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc) throw ();

extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc) throw ();



extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject) throw ();



extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept) throw ();

extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept) throw ();


extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle) throw ();
# 174 "/usr/include/wchar.h" 3 4
extern wchar_t *wcstok (wchar_t *__restrict __s, __const wchar_t *__restrict __delim, wchar_t **__restrict __ptr) throw ();




extern size_t __wcslen (__const wchar_t *__s) throw ();
extern size_t wcslen (__const wchar_t *__s) throw ();



extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen) throw ();




extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n) throw ();


extern int wmemcmp (__const wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ();



extern wchar_t *wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ();




extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw ();



extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();




extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



extern int mbsinit (__const mbstate_t *__ps) throw ();



extern size_t mbrtowc (wchar_t *__restrict __pwc, __const char *__restrict __s, size_t __n, mbstate_t *__p) throw ();




extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps) throw ();



extern size_t __mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ();

extern size_t mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ();





extern __inline size_t mbrlen (__const char *__restrict __s, size_t __n,
                               mbstate_t *__restrict __ps) throw ()
{ return (__ps != __null
          ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }




extern size_t mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ();





extern size_t wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ();







extern size_t mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ();





extern size_t wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ();
# 277 "/usr/include/wchar.h" 3 4
extern int wcwidth (wint_t __c) throw ();



extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();





extern double wcstod (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ();




extern float wcstof (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ();

extern long double wcstold (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ();






extern long int wcstol (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();




extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();






__extension__
extern long long int wcstoq (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();




__extension__
extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();







__extension__
extern long long int wcstoll (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();




__extension__
extern unsigned long long int wcstoull (__const wchar_t * __restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();
# 355 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 356 "/usr/include/wchar.h" 2 3 4



extern long int __wcstol_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();



extern unsigned long int __wcstoul_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();



__extension__
extern long long int __wcstoll_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();



__extension__
extern unsigned long long int __wcstoull_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();





extern double __wcstod_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();



extern float __wcstof_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();



extern long double __wcstold_l (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();







extern double __wcstod_internal (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __group) throw ();


extern float __wcstof_internal (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __group) throw ();


extern long double __wcstold_internal (__const wchar_t * __restrict __nptr, wchar_t **__restrict __endptr, int __group) throw ();





extern long int __wcstol_internal (__const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, int __group) throw ();





extern unsigned long int __wcstoul_internal (__const wchar_t * __restrict __nptr, wchar_t ** __restrict __endptr, int __base, int __group) throw ();







__extension__
extern long long int __wcstoll_internal (__const wchar_t * __restrict __nptr, wchar_t **__restrict __endptr, int __base, int __group) throw ();






__extension__
extern unsigned long long int __wcstoull_internal (__const wchar_t * __restrict __nptr, wchar_t ** __restrict __endptr, int __base, int __group) throw ();
# 443 "/usr/include/wchar.h" 3 4
extern __inline double wcstod (__const wchar_t *__restrict __nptr,
                               wchar_t **__restrict __endptr) throw ()
{ return __wcstod_internal (__nptr, __endptr, 0); }
extern __inline long int wcstol (__const wchar_t *__restrict __nptr,
                                 wchar_t **__restrict __endptr,
                                 int __base) throw ()
{ return __wcstol_internal (__nptr, __endptr, __base, 0); }
extern __inline unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
                                           wchar_t **__restrict __endptr,
                                           int __base) throw ()
{ return __wcstoul_internal (__nptr, __endptr, __base, 0); }


extern __inline float wcstof (__const wchar_t *__restrict __nptr,
                              wchar_t **__restrict __endptr) throw ()
{ return __wcstof_internal (__nptr, __endptr, 0); }
extern __inline long double wcstold (__const wchar_t *__restrict __nptr,
                                         wchar_t **__restrict __endptr) throw ()
{ return __wcstold_internal (__nptr, __endptr, 0); }


__extension__
extern __inline long long int wcstoq (__const wchar_t *__restrict __nptr,
                                      wchar_t **__restrict __endptr,
                                      int __base) throw ()
{ return __wcstoll_internal (__nptr, __endptr, __base, 0); }
__extension__
extern __inline unsigned long long int wcstouq (__const wchar_t *
                                                __restrict __nptr,
                                                wchar_t **__restrict __endptr,
                                                int __base) throw ()
{ return __wcstoull_internal (__nptr, __endptr, __base, 0); }







extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();



extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ();
# 502 "/usr/include/wchar.h" 3 4
}
# 47 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 2 3
# 61 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 3
namespace std
{
  using ::mbstate_t;
}
# 38 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/fpos.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/fpos.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++io.h" 1 3
# 35 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++io.h" 3
# 1 "/usr/include/stdio.h" 1 3 4
# 36 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++io.h" 2 3
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 37 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++io.h" 2 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 1 3
# 39 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 2 3




# 1 "/usr/include/pthread.h" 1 3 4
# 18 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 19 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/sched.h" 1 3 4
# 23 "/usr/include/sched.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 24 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/bits/types.h" 1 3 4
# 27 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/time.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/bits/sched.h" 1 3 4
# 47 "/usr/include/bits/sched.h" 3 4
struct sched_param
  {
    int sched_priority;
  };

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack, int __flags, void *__arg) throw ();



}
# 33 "/usr/include/sched.h" 2 3 4

extern "C" {


extern int __sched_setparam (__pid_t __pid, __const struct sched_param *__param) throw ();

extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param) throw ();



extern int __sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();


extern int __sched_setscheduler (__pid_t __pid, int __policy, __const struct sched_param *__param) throw ();

extern int sched_setscheduler (__pid_t __pid, int __policy, __const struct sched_param *__param) throw ();



extern int __sched_getscheduler (__pid_t __pid) throw ();
extern int sched_getscheduler (__pid_t __pid) throw ();


extern int __sched_yield (void) throw ();
extern int sched_yield (void) throw ();


extern int __sched_get_priority_max (int __algorithm) throw ();
extern int sched_get_priority_max (int __algorithm) throw ();


extern int __sched_get_priority_min (int __algorithm) throw ();
extern int sched_get_priority_min (int __algorithm) throw ();


extern int __sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();

}
# 21 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 28 "/usr/include/time.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 29 "/usr/include/time.h" 2 3 4

extern "C" {







# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 43 "/usr/include/time.h" 2 3 4
# 95 "/usr/include/time.h" 3 4
struct tm
{
  int tm_sec;
  int tm_min;
  int tm_hour;
  int tm_mday;
  int tm_mon;
  int tm_year;
  int tm_wday;
  int tm_yday;
  int tm_isdst;


  long int tm_gmtoff;
  __const char *tm_zone;




};




extern clock_t clock (void) throw ();


extern time_t time (time_t *__timer) throw ();


extern double difftime (time_t __time1, time_t __time0) throw ()
     __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) throw ();





extern size_t strftime (char *__restrict __s, size_t __maxsize, __const char *__restrict __format, __const struct tm *__restrict __tp) throw ();






extern char *strptime (__const char *__s, __const char *__fmt, struct tm *__tp) throw ();






extern struct tm *gmtime (__const time_t *__timer) throw ();



extern struct tm *localtime (__const time_t *__timer) throw ();




extern struct tm *__gmtime_r (__const time_t *__restrict __timer, struct tm *__restrict __tp) throw ();

extern struct tm *gmtime_r (__const time_t *__restrict __timer, struct tm *__restrict __tp) throw ();




extern struct tm *localtime_r (__const time_t *__restrict __timer, struct tm *__restrict __tp) throw ();





extern char *asctime (__const struct tm *__tp) throw ();


extern char *ctime (__const time_t *__timer) throw ();






extern char *asctime_r (__const struct tm *__restrict __tp, char *__restrict __buf) throw ();



extern char *ctime_r (__const time_t *__restrict __timer, char *__restrict __buf) throw ();





extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) throw ();



extern int daylight;
extern long int timezone;





extern int stime (__const time_t *__when) throw ();
# 228 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw ();





extern int nanosleep (__const struct timespec *__requested_time, struct timespec *__remaining) throw ();
# 257 "/usr/include/time.h" 3 4
extern int getdate_err;





extern struct tm *getdate (__const char *__string) throw ();
# 272 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string, struct tm *__restrict __resbufp) throw ();




}
# 22 "/usr/include/pthread.h" 2 3 4


# 1 "/usr/include/signal.h" 1 3 4
# 29 "/usr/include/signal.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 30 "/usr/include/signal.h" 2 3 4

extern "C" {

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 34 "/usr/include/signal.h" 2 3 4
# 49 "/usr/include/signal.h" 3 4
typedef __sigset_t sigset_t;
# 362 "/usr/include/signal.h" 3 4
}
# 25 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 26 "/usr/include/pthread.h" 2 3 4


extern "C" {
# 49 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_CREATE_JOINABLE,

  PTHREAD_CREATE_DETACHED

};

enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};

enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};

enum
{
  PTHREAD_MUTEX_FAST_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP

  ,
  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL

};

enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};


enum
{
  PTHREAD_RWLOCK_PREFER_READER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NP,
  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
};






struct _pthread_cleanup_buffer
{
  void (*__routine) (void *);
  void *__arg;
  int __canceltype;
  struct _pthread_cleanup_buffer *__prev;
};



enum
{
  PTHREAD_CANCEL_ENABLE,

  PTHREAD_CANCEL_DISABLE

};
enum
{
  PTHREAD_CANCEL_DEFERRED,

  PTHREAD_CANCEL_ASYNCHRONOUS

};
# 141 "/usr/include/pthread.h" 3 4
extern int pthread_create (pthread_t *__thread, __const pthread_attr_t *__attr, void *(*__start_routine) (void *), void *__arg) throw ();





extern pthread_t pthread_self (void) throw ();


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();


extern void pthread_exit (void *__retval) throw () __attribute__ ((__noreturn__));




extern int pthread_join (pthread_t __th, void **__thread_return) throw ();





extern int pthread_detach (pthread_t __th) throw ();







extern int pthread_attr_init (pthread_attr_t *__attr) throw ();


extern int pthread_attr_destroy (pthread_attr_t *__attr) throw ();


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, int __detachstate) throw ();



extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr, int *__detachstate) throw ();



extern int pthread_attr_setschedparam (pthread_attr_t *__attr, __const struct sched_param *__param) throw ();



extern int pthread_attr_getschedparam (__const pthread_attr_t *__attr, struct sched_param *__param) throw ();



extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) throw ();



extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__attr, int *__policy) throw ();



extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, int __inherit) throw ();



extern int pthread_attr_getinheritsched (__const pthread_attr_t *__attr, int *__inherit) throw ();



extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) throw ();


extern int pthread_attr_getscope (__const pthread_attr_t *__attr, int *__scope) throw ();




extern int pthread_attr_setguardsize (pthread_attr_t *__attr, size_t __guardsize) throw ();



extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr, size_t *__guardsize) throw ();







extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr) throw ();



extern int pthread_attr_getstackaddr (__const pthread_attr_t *__attr, void **__stackaddr) throw ();





extern int pthread_attr_setstacksize (pthread_attr_t *__attr, size_t __stacksize) throw ();



extern int pthread_attr_getstacksize (__const pthread_attr_t *__attr, size_t *__stacksize) throw ();






extern int pthread_setschedparam (pthread_t __target_thread, int __policy, __const struct sched_param *__param) throw ();



extern int pthread_getschedparam (pthread_t __target_thread, int *__policy, struct sched_param *__param) throw ();





extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();






extern int __pthread_mutex_init (pthread_mutex_t *__mutex, __const pthread_mutexattr_t *__mutex_attr) throw ();

extern int pthread_mutex_init (pthread_mutex_t *__mutex, __const pthread_mutexattr_t *__mutex_attr) throw ();



extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex) throw ();
extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw ();


extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex) throw ();
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw ();


extern int __pthread_mutex_lock (pthread_mutex_t *__mutex) throw ();
extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw ();


extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex) throw ();
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw ();






extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw ();
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw ();


extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw ();
extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw ();





extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) throw ();

extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) throw ();



extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__attr, int *__kind) throw ();
# 323 "/usr/include/pthread.h" 3 4
extern int pthread_cond_init (pthread_cond_t *__cond, __const pthread_condattr_t *__cond_attr) throw ();



extern int pthread_cond_destroy (pthread_cond_t *__cond) throw ();


extern int pthread_cond_signal (pthread_cond_t *__cond) throw ();


extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw ();



extern int pthread_cond_wait (pthread_cond_t *__cond, pthread_mutex_t *__mutex) throw ();






extern int pthread_cond_timedwait (pthread_cond_t *__cond, pthread_mutex_t *__mutex, __const struct timespec *__abstime) throw ();






extern int pthread_condattr_init (pthread_condattr_t *__attr) throw ();


extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw ();







extern int pthread_rwlock_init (pthread_rwlock_t *__rwlock, __const pthread_rwlockattr_t *__attr) throw ();



extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw ();


extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw ();





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw ();


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw ();


extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *__attr, int *__pshared) throw ();




extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, int __pshared) throw ();



extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr, int *__pref) throw ();




extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, int __pref) throw ();
# 420 "/usr/include/pthread.h" 3 4
extern int __pthread_key_create (pthread_key_t *__key, void (*__destr_function) (void *)) throw ();

extern int pthread_key_create (pthread_key_t *__key, void (*__destr_function) (void *)) throw ();



extern int pthread_key_delete (pthread_key_t __key) throw ();


extern int __pthread_setspecific (pthread_key_t __key, __const void *__pointer) throw ();

extern int pthread_setspecific (pthread_key_t __key, __const void *__pointer) throw ();



extern void *__pthread_getspecific (pthread_key_t __key) throw ();
extern void *pthread_getspecific (pthread_key_t __key) throw ();
# 445 "/usr/include/pthread.h" 3 4
extern int __pthread_once (pthread_once_t *__once_control, void (*__init_routine) (void)) throw ();

extern int pthread_once (pthread_once_t *__once_control, void (*__init_routine) (void)) throw ();







extern int pthread_setcancelstate (int __state, int *__oldstate) throw ();



extern int pthread_setcanceltype (int __type, int *__oldtype) throw ();


extern int pthread_cancel (pthread_t __thread) throw ();




extern void pthread_testcancel (void) throw ();
# 481 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer, void (*__routine) (void *), void *__arg) throw ();
# 491 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer, int __execute) throw ();
# 502 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer, void (*__routine) (void *), void *__arg) throw ();
# 513 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer, int __execute) throw ();




# 1 "/usr/include/bits/sigthread.h" 1 3 4
# 31 "/usr/include/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how, __const __sigset_t *__newmask, __sigset_t *__oldmask) throw ();



extern int pthread_kill (pthread_t __thread, int __signo) throw ();
# 519 "/usr/include/pthread.h" 2 3 4
# 534 "/usr/include/pthread.h" 3 4
extern int __pthread_atfork (void (*__prepare) (void), void (*__parent) (void), void (*__child) (void)) throw ();


extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void), void (*__child) (void)) throw ();






extern void pthread_kill_other_threads_np (void) throw ();



extern void __pthread_initialize (void) throw ();

}
# 45 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 2 3
# 64 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 3
namespace std {
  typedef pthread_mutex_t __mutext_type;
}
# 38 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++io.h" 2 3

namespace std {


  typedef long streamoff;
  typedef ptrdiff_t streamsize;




  typedef fpos_t __c_streampos;


  typedef __mutext_type __c_lock;






  typedef FILE __c_file_type;


  struct __ios_flags
 {
   typedef short __int_type;

   static const __int_type _S_boolalpha = 0x0001;
   static const __int_type _S_dec = 0x0002;
   static const __int_type _S_fixed = 0x0004;
   static const __int_type _S_hex = 0x0008;
   static const __int_type _S_internal = 0x0010;
   static const __int_type _S_left = 0x0020;
   static const __int_type _S_oct = 0x0040;
   static const __int_type _S_right = 0x0080;
   static const __int_type _S_scientific = 0x0100;
   static const __int_type _S_showbase = 0x0200;
   static const __int_type _S_showpoint = 0x0400;
   static const __int_type _S_showpos = 0x0800;
   static const __int_type _S_skipws = 0x1000;
   static const __int_type _S_unitbuf = 0x2000;
   static const __int_type _S_uppercase = 0x4000;
   static const __int_type _S_adjustfield = 0x0020 | 0x0080 | 0x0010;
   static const __int_type _S_basefield = 0x0002 | 0x0040 | 0x0008;
   static const __int_type _S_floatfield = 0x0100 | 0x0004;


   static const __int_type _S_badbit = 0x01;
   static const __int_type _S_eofbit = 0x02;
   static const __int_type _S_failbit = 0x04;


   static const __int_type _S_app = 0x01;
   static const __int_type _S_ate = 0x02;
   static const __int_type _S_bin = 0x04;
   static const __int_type _S_in = 0x08;
   static const __int_type _S_out = 0x10;
   static const __int_type _S_trunc = 0x20;
  };

}
# 41 "/opt/gcc3/include/g++-v3/bits/fpos.h" 2 3

namespace std {




  template<typename _StateT>
    class fpos
    {
    public:

      typedef _StateT __state_type;

    private:
      __state_type _M_st;
      streamoff _M_off;

    public:
      __state_type
      state() const { return _M_st; }

      void
      state(__state_type __st) { _M_st = __st; }



      fpos(): _M_st(__state_type()), _M_off(streamoff()) { }

      fpos(streamoff __off, __state_type __st = __state_type())
      : _M_st(__st), _M_off(__off) { }

      operator streamoff() const { return _M_off; }

      fpos&
      operator+=(streamoff __off) { _M_off += __off; return *this; }

      fpos&
      operator-=(streamoff __off) { _M_off -= __off; return *this; }

      bool
      operator==(const fpos& __pos) const { return _M_off == __pos._M_off; }

      bool
      operator!=(const fpos& __pos) const { return _M_off != __pos._M_off; }

      streamoff
      _M_position() const { return _M_off; }

      void
      _M_position(streamoff __off) { _M_off = __off; }
    };

  template<typename _State>
    inline fpos<_State>
    operator+(const fpos<_State>& __pos, streamoff __off)
    {
      fpos<_State> t(__pos);
      return t += __off;
    }

  template<typename _State>
    inline fpos<_State>
    operator-(const fpos<_State>& __pos, streamoff __off)
    {
      fpos<_State> t(__pos);
      return t -= __off;
    }

  template<typename _State>
    inline streamoff
    operator-(const fpos<_State>& __pos1, const fpos<_State>& __pos2)
    { return __pos1._M_position() - __pos2._M_position(); }

}
# 40 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 2 3

namespace std {







    typedef fpos<mbstate_t> streampos;
# 59 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits
    {
      typedef _CharT char_type;

      typedef unsigned long int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
        for (size_t __i = 0; __i < __n; ++__i)
          if (!eq(__s1[__i], __s2[__i]))
            return lt(__s1[__i], __s2[__i]) ? -1 : 1;
        return 0;
      }

      static size_t
      length(const char_type* __s)
      {
        const char_type* __p = __s;
        while (*__p) ++__p;
        return (__p - __s);
      }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
        for (const char_type* __p = __s; size_t(__p - __s) < __n; ++__p)
          if (*__p == __a) return __p;
        return 0;
      }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
        for (char_type* __p = __s; __p < __s + __n; ++__p)
          assign(*__p, __a);
        return __s;
      }

      static char_type
      to_char_type(const int_type& __c)
      { return char_type(__c); }

      static int_type
      to_int_type(const char_type& __c) { return int_type(__c); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static state_type
      _S_get_state(const pos_type& __pos) { return __pos.state(); }

      static int_type
      eof() { return static_cast<int_type>(-1); }

      static int_type
      _S_eos() { return char_type(); }

      static int_type
      not_eof(const int_type& __c)
      { return eq_int_type(__c, eof()) ? int_type(0) : __c; }
    };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef unsigned int int_type;
      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;

      static void
      assign(char_type& __c1, const char_type& __c2)
      { __c1 = __c2; }

      static bool
      eq(const char_type& __c1, const char_type& __c2)
      { return __c1 == __c2; }

      static bool
      lt(const char_type& __c1, const char_type& __c2)
      { return __c1 < __c2; }

      static int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      { return memcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return static_cast<const char_type*>(memchr(__s, __a, __n)); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(memset(__s, __a, __n)); }

      static char_type
      to_char_type(const int_type& __c)
      { return static_cast<char_type>(__c); }



      static int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }

      static state_type
      _S_get_state(const pos_type& __pos) { return __pos.state(); }

      static int_type
      eof() { return static_cast<int_type>((-1)); }

      static int_type
      _S_eos() { return char_type(); }

      static int_type
      not_eof(const int_type& __c)
      { return (__c == eof()) ? 0 : __c; }
  };
# 294 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 3
  template<typename _CharT, typename _Traits>
    struct _Char_traits_match
    {
      _CharT _M_c;
      _Char_traits_match(_CharT const& __c) : _M_c(__c) { }

      bool
      operator()(_CharT const& __a) { return _Traits::eq(_M_c, __a); }
    };

}
# 20 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 2 3

namespace std {

template <class _CharT,
          class _Traits = char_traits<_CharT>,
          class _Alloc = allocator<_CharT> >
class basic_string;

typedef basic_string<char> string;




}
# 39 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 1 3
# 30 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 32 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cwchar.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 2 3

namespace std {


  template<typename _CharT> struct char_traits;
  template<typename _Alloc> class allocator;


  template<> class char_traits<char>;




  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_iostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
            typename _Alloc = allocator<_CharT> >
  class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
  class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
  class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
  class basic_stringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
  class ostreambuf_iterator;



  class ios_base;


  template<class _State> struct fpos;





  typedef fpos<mbstate_t> streampos;





  typedef basic_ios<char> ios;
  typedef basic_streambuf<char> streambuf;
  typedef basic_istream<char> istream;
  typedef basic_ostream<char> ostream;
  typedef basic_iostream<char> iostream;
  typedef basic_stringbuf<char> stringbuf;
  typedef basic_istringstream<char> istringstream;
  typedef basic_ostringstream<char> ostringstream;
  typedef basic_stringstream<char> stringstream;
  typedef basic_filebuf<char> filebuf;
  typedef basic_ifstream<char> ifstream;
  typedef basic_ofstream<char> ofstream;
  typedef basic_fstream<char> fstream;
# 148 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 3
}
# 33 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 232 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 3
template <class _Tp>
struct _Mutable_trait {
  typedef _Tp _Type;
};
template <class _Tp>
struct _Mutable_trait<const _Tp> {
  typedef _Tp _Type;
};



template <class _Type>
void __sink_unused_warning(_Type) { }

template <class _TypeX, class _TypeY>
struct _STL_CONVERT_ERROR {
  static void
  __type_X_is_not_convertible_to_type_Y(_TypeX __x, _TypeY) {
    _TypeY __y = __x;
    __sink_unused_warning(__y);
  }
};


template <class _Type> struct __check_equal { };

template <class _TypeX, class _TypeY>
struct _STL_SAME_TYPE_ERROR {
  static void
  __type_X_not_same_as_type_Y(_TypeX , _TypeY ) {
    __check_equal<_TypeX> t1 = __check_equal<_TypeY>();
  }
};




template <class _Func, class _Ret>
struct _STL_GENERATOR_ERROR {
  static _Ret __generator_requirement_violation(_Func& __f) {
    return __f();
  }
};

template <class _Func>
struct _STL_GENERATOR_ERROR<_Func, void> {
  static void __generator_requirement_violation(_Func& __f) {
    __f();
  }
};


template <class _Func, class _Ret, class _Arg>
struct _STL_UNARY_FUNCTION_ERROR {
  static _Ret
  __unary_function_requirement_violation(_Func& __f,
                                          const _Arg& __arg) {
    return __f(__arg);
  }
};

template <class _Func, class _Arg>
struct _STL_UNARY_FUNCTION_ERROR<_Func, void, _Arg> {
  static void
  __unary_function_requirement_violation(_Func& __f,
                                          const _Arg& __arg) {
    __f(__arg);
  }
};

template <class _Func, class _Ret, class _First, class _Second>
struct _STL_BINARY_FUNCTION_ERROR {
  static _Ret
  __binary_function_requirement_violation(_Func& __f,
                                          const _First& __first,
                                          const _Second& __second) {
    return __f(__first, __second);
  }
};

template <class _Func, class _First, class _Second>
struct _STL_BINARY_FUNCTION_ERROR<_Func, void, _First, _Second> {
  static void
  __binary_function_requirement_violation(_Func& __f,
                                          const _First& __first,
                                          const _Second& __second) {
    __f(__first, __second);
  }
};
# 338 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 3
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_EQUAL_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first == __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first == __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_NOT_EQUAL_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first != __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first != __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_LESS_THAN_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first < __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first < __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_LESS_EQUAL_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first <= __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first <= __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_GREATER_THAN_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first > __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first > __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_GREATER_EQUAL_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first >= __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first >= __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_PLUS_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first + __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first + __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_TIMES_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first * __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first * __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_DIVIDE_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first / __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first / __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_SUBTRACT_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first - __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first - __second; } };
template <class _Ret, class _First, class _Second> struct _STL_BINARY_OP_MOD_ERROR { static _Ret __const_binary_operator_requirement_violation(const _First& __first, const _Second& __second) { return __first % __second; } static _Ret __binary_operator_requirement_violation(_First& __first, _Second& __second) { return __first % __second; } };
# 360 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 3
struct _STL_ERROR {

  template <class _Type>
  static _Type
  __default_constructor_requirement_violation(_Type) {
    return _Type();
  }
  template <class _Type>
  static _Type
  __assignment_operator_requirement_violation(_Type __a) {
    __a = __a;
    return __a;
  }
  template <class _Type>
  static _Type
  __copy_constructor_requirement_violation(_Type __a) {
    _Type __c(__a);
    return __c;
  }
  template <class _Type>
  static _Type
  __const_parameter_required_for_copy_constructor(_Type ,
                                                  const _Type& __b) {
    _Type __c(__b);
    return __c;
  }
  template <class _Type>
  static _Type
  __const_parameter_required_for_assignment_operator(_Type __a,
                                                     const _Type& __b) {
    __a = __b;
    return __a;
  }
  template <class _Type>
  static _Type
  __less_than_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a < __b) return __a;
    return __b;
  }
  template <class _Type>
  static _Type
  __equality_comparable_requirement_violation(_Type __a, _Type __b) {
    if (__a == __b || __a != __b) return __a;
    return __b;
  }
  template <class _Iterator>
  static void
  __dereference_operator_requirement_violation(_Iterator __i) {
    __sink_unused_warning(*__i);
  }
  template <class _Iterator>
  static void
  __dereference_operator_and_assignment_requirement_violation(_Iterator __i) {
    *__i = *__i;
  }
  template <class _Iterator>
  static void
  __preincrement_operator_requirement_violation(_Iterator __i) {
    ++__i;
  }
  template <class _Iterator>
  static void
  __postincrement_operator_requirement_violation(_Iterator __i) {
    __i++;
  }
  template <class _Iterator>
  static void
  __predecrement_operator_requirement_violation(_Iterator __i) {
    --__i;
  }
  template <class _Iterator>
  static void
  __postdecrement_operator_requirement_violation(_Iterator __i) {
    __i--;
  }
  template <class _Iterator, class _Type>
  static void
  __postincrement_operator_and_assignment_requirement_violation(_Iterator __i,
                                                                _Type __t) {
    *__i++ = __t;
  }
  template <class _Iterator, class _Distance>
  static _Iterator
  __iterator_addition_assignment_requirement_violation(_Iterator __i,
                                                       _Distance __n) {
    __i += __n;
    return __i;
  }
  template <class _Iterator, class _Distance>
  static _Iterator
  __iterator_addition_requirement_violation(_Iterator __i, _Distance __n) {
    __i = __i + __n;
    __i = __n + __i;
    return __i;
  }
  template <class _Iterator, class _Distance>
  static _Iterator
  __iterator_subtraction_assignment_requirement_violation(_Iterator __i,
                                                          _Distance __n) {
    __i -= __n;
    return __i;
  }
  template <class _Iterator, class _Distance>
  static _Iterator
  __iterator_subtraction_requirement_violation(_Iterator __i, _Distance __n) {
    __i = __i - __n;
    return __i;
  }
  template <class _Iterator, class _Distance>
  static _Distance
  __difference_operator_requirement_violation(_Iterator __i, _Iterator __j,
                                              _Distance __n) {
    __n = __i - __j;
    return __n;
  }
  template <class _Exp, class _Type, class _Distance>
  static _Type
  __element_access_operator_requirement_violation(_Exp __x, _Type*,
                                                  _Distance __n) {
    return __x[__n];
  }
  template <class _Exp, class _Type, class _Distance>
  static void
  __element_assignment_operator_requirement_violation(_Exp __x,
                                                      _Type* __t,
                                                      _Distance __n) {
    __x[__n] = *__t;
  }

};



namespace std {
template <class _Iterator> struct iterator_traits;
}

template <class _Iter>
struct __value_type_type_definition_requirement_violation {
  typedef typename std::iterator_traits<_Iter>::value_type value_type;
};

template <class _Iter>
struct __difference_type_type_definition_requirement_violation {
  typedef typename std::iterator_traits<_Iter>::difference_type
          difference_type;
};

template <class _Iter>
struct __reference_type_definition_requirement_violation {
  typedef typename std::iterator_traits<_Iter>::reference reference;
};

template <class _Iter>
struct __pointer_type_definition_requirement_violation {
  typedef typename std::iterator_traits<_Iter>::pointer pointer;
};

template <class _Iter>
struct __iterator_category_type_definition_requirement_violation {
  typedef typename std::iterator_traits<_Iter>::iterator_category
          iterator_category;
};




template <class _Type>
struct _Assignable_concept_specification {
  static void _Assignable_requirement_violation(_Type __a) {
    _STL_ERROR::__assignment_operator_requirement_violation(__a);
    _STL_ERROR::__copy_constructor_requirement_violation(__a);
    _STL_ERROR::__const_parameter_required_for_copy_constructor(__a,__a);
    _STL_ERROR::__const_parameter_required_for_assignment_operator(__a,__a);
  }
};




template <class _Type>
struct _DefaultConstructible_concept_specification {
  static void _DefaultConstructible_requirement_violation(_Type __a) {
    _STL_ERROR::__default_constructor_requirement_violation(__a);
  }
};



template <class _Type>
struct _EqualityComparable_concept_specification {
  static void _EqualityComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__equality_comparable_requirement_violation(__a, __a);
  }
};


template <class _Type>
struct _LessThanComparable_concept_specification {
  static void _LessThanComparable_requirement_violation(_Type __a) {
    _STL_ERROR::__less_than_comparable_requirement_violation(__a, __a);
  }
};



template <class _TrivialIterator>
struct _TrivialIterator_concept_specification {
static void
_TrivialIterator_requirement_violation(_TrivialIterator __i) {
  typedef typename
    __value_type_type_definition_requirement_violation<_TrivialIterator>::
    value_type __T;

  _Assignable_concept_specification<_TrivialIterator>::
    _Assignable_requirement_violation(__i);

  _DefaultConstructible_concept_specification<_TrivialIterator>::
    _DefaultConstructible_requirement_violation(__i);

  _EqualityComparable_concept_specification<_TrivialIterator>::
    _EqualityComparable_requirement_violation(__i);

  _STL_ERROR::__dereference_operator_requirement_violation(__i);
}
};

template <class _TrivialIterator>
struct _Mutable_TrivialIterator_concept_specification {
static void
_Mutable_TrivialIterator_requirement_violation(_TrivialIterator __i) {
  _TrivialIterator_concept_specification<_TrivialIterator>::
    _TrivialIterator_requirement_violation(__i);

  _STL_ERROR::__dereference_operator_and_assignment_requirement_violation(__i);
}
};



template <class _InputIterator>
struct _InputIterator_concept_specification {
static void
_InputIterator_requirement_violation(_InputIterator __i) {

  _TrivialIterator_concept_specification<_InputIterator>::
    _TrivialIterator_requirement_violation(__i);

  __difference_type_type_definition_requirement_violation<_InputIterator>();
  __reference_type_definition_requirement_violation<_InputIterator>();
  __pointer_type_definition_requirement_violation<_InputIterator>();
  __iterator_category_type_definition_requirement_violation<_InputIterator>();

  _STL_ERROR::__preincrement_operator_requirement_violation(__i);
  _STL_ERROR::__postincrement_operator_requirement_violation(__i);
}
};



template <class _OutputIterator>
struct _OutputIterator_concept_specification {
static void
_OutputIterator_requirement_violation(_OutputIterator __i) {

  _Assignable_concept_specification<_OutputIterator>::
    _Assignable_requirement_violation(__i);

  __iterator_category_type_definition_requirement_violation<_OutputIterator>();

  _STL_ERROR::__dereference_operator_requirement_violation(__i);
  _STL_ERROR::__preincrement_operator_requirement_violation(__i);
  _STL_ERROR::__postincrement_operator_requirement_violation(__i);
  _STL_ERROR::
    __postincrement_operator_and_assignment_requirement_violation(__i, *__i);
}
};



template <class _ForwardIterator>
struct _ForwardIterator_concept_specification {
static void
_ForwardIterator_requirement_violation(_ForwardIterator __i) {

  _InputIterator_concept_specification<_ForwardIterator>::
    _InputIterator_requirement_violation(__i);
}
};

template <class _ForwardIterator>
struct _Mutable_ForwardIterator_concept_specification {
static void
_Mutable_ForwardIterator_requirement_violation(_ForwardIterator __i) {
  _ForwardIterator_concept_specification<_ForwardIterator>::
    _ForwardIterator_requirement_violation(__i);

  _OutputIterator_concept_specification<_ForwardIterator>::
    _OutputIterator_requirement_violation(__i);
}
};



template <class _BidirectionalIterator>
struct _BidirectionalIterator_concept_specification {
static void
_BidirectionalIterator_requirement_violation(_BidirectionalIterator __i) {

  _ForwardIterator_concept_specification<_BidirectionalIterator>::
    _ForwardIterator_requirement_violation(__i);

  _STL_ERROR::__predecrement_operator_requirement_violation(__i);
  _STL_ERROR::__postdecrement_operator_requirement_violation(__i);
}
};

template <class _BidirectionalIterator>
struct _Mutable_BidirectionalIterator_concept_specification {
static void
_Mutable_BidirectionalIterator_requirement_violation(
       _BidirectionalIterator __i)
{
  _BidirectionalIterator_concept_specification<_BidirectionalIterator>::
    _BidirectionalIterator_requirement_violation(__i);

  _Mutable_ForwardIterator_concept_specification<_BidirectionalIterator>::
    _Mutable_ForwardIterator_requirement_violation(__i);
  typedef typename
    __value_type_type_definition_requirement_violation<
    _BidirectionalIterator>::value_type __T;
  typename _Mutable_trait<__T>::_Type* __tmp_ptr = 0;

  _STL_ERROR::
    __postincrement_operator_and_assignment_requirement_violation(__i,
                                                                  *__tmp_ptr);
}
};



template <class _RandAccIter>
struct _RandomAccessIterator_concept_specification {
static void
_RandomAccessIterator_requirement_violation(_RandAccIter __i) {

  _BidirectionalIterator_concept_specification<_RandAccIter>::
    _BidirectionalIterator_requirement_violation(__i);

  _LessThanComparable_concept_specification<_RandAccIter>::
    _LessThanComparable_requirement_violation(__i);
  typedef typename
        __value_type_type_definition_requirement_violation<_RandAccIter>
        ::value_type
    value_type;
  typedef typename
        __difference_type_type_definition_requirement_violation<_RandAccIter>
        ::difference_type
    _Dist;
  typedef typename _Mutable_trait<_Dist>::_Type _MutDist;


  _STL_ERROR::__iterator_addition_assignment_requirement_violation(__i,
                                                                   _MutDist());
  _STL_ERROR::__iterator_addition_requirement_violation(__i,
                                                        _MutDist());
  _STL_ERROR::
    __iterator_subtraction_assignment_requirement_violation(__i,
                                                            _MutDist());
  _STL_ERROR::__iterator_subtraction_requirement_violation(__i,
                                                           _MutDist());
  _STL_ERROR::__difference_operator_requirement_violation(__i, __i,
                                                          _MutDist());
  typename _Mutable_trait<value_type>::_Type* __dummy_ptr = 0;
  _STL_ERROR::__element_access_operator_requirement_violation(__i,
                                                              __dummy_ptr,
                                                              _MutDist());
}
};

template <class _RandAccIter>
struct _Mutable_RandomAccessIterator_concept_specification {
static void
_Mutable_RandomAccessIterator_requirement_violation(_RandAccIter __i)
{
  _RandomAccessIterator_concept_specification<_RandAccIter>::
    _RandomAccessIterator_requirement_violation(__i);

  _Mutable_BidirectionalIterator_concept_specification<_RandAccIter>::
    _Mutable_BidirectionalIterator_requirement_violation(__i);
  typedef typename
        __value_type_type_definition_requirement_violation<_RandAccIter>
        ::value_type
    value_type;
  typedef typename
        __difference_type_type_definition_requirement_violation<_RandAccIter>
        ::difference_type
    _Dist;

  typename _Mutable_trait<value_type>::_Type* __tmp_ptr = 0;

  _STL_ERROR::__element_assignment_operator_requirement_violation(__i,
                  __tmp_ptr, _Dist());
}
};







template <class Type> struct __value_type__typedef_requirement_violation { typedef typename Type::value_type value_type; };
template <class Type> struct __difference_type__typedef_requirement_violation { typedef typename Type::difference_type difference_type; };
template <class Type> struct __size_type__typedef_requirement_violation { typedef typename Type::size_type size_type; };
template <class Type> struct __reference__typedef_requirement_violation { typedef typename Type::reference reference; };
template <class Type> struct __const_reference__typedef_requirement_violation { typedef typename Type::const_reference const_reference; };
template <class Type> struct __pointer__typedef_requirement_violation { typedef typename Type::pointer pointer; };
template <class Type> struct __const_pointer__typedef_requirement_violation { typedef typename Type::const_pointer const_pointer; };


template <class _Alloc>
struct _Allocator_concept_specification {
static void
_Allocator_requirement_violation(_Alloc __a) {

  _DefaultConstructible_concept_specification<_Alloc>::
    _DefaultConstructible_requirement_violation(__a);

  _EqualityComparable_concept_specification<_Alloc>::
    _EqualityComparable_requirement_violation(__a);

  __value_type__typedef_requirement_violation<_Alloc>();
  __difference_type__typedef_requirement_violation<_Alloc>();
  __size_type__typedef_requirement_violation<_Alloc>();
  __reference__typedef_requirement_violation<_Alloc>();
  __const_reference__typedef_requirement_violation<_Alloc>();
  __pointer__typedef_requirement_violation<_Alloc>();
  __const_pointer__typedef_requirement_violation<_Alloc>();
  typedef typename _Alloc::value_type _Tp;


}
};
# 39 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 2 3

namespace std {

struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};






template <class _Tp, class _Distance> struct input_iterator {
  typedef input_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

struct output_iterator {
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;
};

template <class _Tp, class _Distance> struct forward_iterator {
  typedef forward_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};


template <class _Tp, class _Distance> struct bidirectional_iterator {
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

template <class _Tp, class _Distance> struct random_access_iterator {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};


template <class _Category, class _Tp, class _Distance = ptrdiff_t,
          class _Pointer = _Tp*, class _Reference = _Tp&>
struct iterator {
  typedef _Category iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Pointer pointer;
  typedef _Reference reference;
};




template <class _Iterator>
struct iterator_traits {
  typedef typename _Iterator::iterator_category iterator_category;
  typedef typename _Iterator::value_type value_type;
  typedef typename _Iterator::difference_type difference_type;
  typedef typename _Iterator::pointer pointer;
  typedef typename _Iterator::reference reference;
};

template <class _Tp>
struct iterator_traits<_Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp* pointer;
  typedef _Tp& reference;
};

template <class _Tp>
struct iterator_traits<const _Tp*> {
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef ptrdiff_t difference_type;
  typedef const _Tp* pointer;
  typedef const _Tp& reference;
};
# 142 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 3
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{
  typedef typename iterator_traits<_Iter>::iterator_category _Category;
  return _Category();
}

template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
__distance_type(const _Iter&)
{
  return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
}

template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
__value_type(const _Iter&)
{
  return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
}

template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
iterator_category(const _Iter& __i) { return __iterator_category(__i); }


template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
distance_type(const _Iter& __i) { return __distance_type(__i); }

template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
value_type(const _Iter& __i) { return __value_type(__i); }
# 267 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 3
template <class _InputIterator, class _Distance>
inline void __distance(_InputIterator __first, _InputIterator __last,
                       _Distance& __n, input_iterator_tag)
{
  while (__first != __last) { ++__first; ++__n; }
}

template <class _RandomAccessIterator, class _Distance>
inline void __distance(_RandomAccessIterator __first,
                       _RandomAccessIterator __last,
                       _Distance& __n, random_access_iterator_tag)
{
  do { void (*__x)( _RandomAccessIterator ) = _RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  __n += __last - __first;
}

template <class _InputIterator, class _Distance>
inline void distance(_InputIterator __first,
                     _InputIterator __last, _Distance& __n)
{
  do { void (*__x)( _InputIterator ) = _InputIterator_concept_specification< _InputIterator > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  __distance(__first, __last, __n, iterator_category(__first));
}



template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
{
  typename iterator_traits<_InputIterator>::difference_type __n = 0;
  while (__first != __last) {
    ++__first; ++__n;
  }
  return __n;
}

template <class _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
           random_access_iterator_tag) {
  do { void (*__x)( _RandomAccessIterator ) = _RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  return __last - __first;
}

template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last) {
  typedef typename iterator_traits<_InputIterator>::iterator_category
    _Category;
  do { void (*__x)( _InputIterator ) = _InputIterator_concept_specification< _InputIterator > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  return __distance(__first, __last, _Category());
}



template <class _InputIter, class _Distance>
inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
  while (__n--) ++__i;
}





template <class _BidirectionalIterator, class _Distance>
inline void __advance(_BidirectionalIterator& __i, _Distance __n,
                      bidirectional_iterator_tag) {
  do { void (*__x)( _BidirectionalIterator ) = _BidirectionalIterator_concept_specification< _BidirectionalIterator > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  if (__n >= 0)
    while (__n--) ++__i;
  else
    while (__n++) --__i;
}





template <class _RandomAccessIterator, class _Distance>
inline void __advance(_RandomAccessIterator& __i, _Distance __n,
                      random_access_iterator_tag) {
  do { void (*__x)( _RandomAccessIterator ) = _RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  __i += __n;
}

template <class _InputIterator, class _Distance>
inline void advance(_InputIterator& __i, _Distance __n) {
  do { void (*__x)( _InputIterator ) = _InputIterator_concept_specification< _InputIterator > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  __advance(__i, __n, iterator_category(__i));
}

}
# 34 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
namespace std {


template <class _Container>
class back_insert_iterator {
protected:
  _Container* container;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) {}
  back_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->push_back(__value);
    return *this;
  }
  back_insert_iterator<_Container>& operator*() { return *this; }
  back_insert_iterator<_Container>& operator++() { return *this; }
  back_insert_iterator<_Container>& operator++(int) { return *this; }
};
# 71 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
  return back_insert_iterator<_Container>(__x);
}

template <class _Container>
class front_insert_iterator {
protected:
  _Container* container;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit front_insert_iterator(_Container& __x) : container(&__x) {}
  front_insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    container->push_front(__value);
    return *this;
  }
  front_insert_iterator<_Container>& operator*() { return *this; }
  front_insert_iterator<_Container>& operator++() { return *this; }
  front_insert_iterator<_Container>& operator++(int) { return *this; }
};
# 110 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
  return front_insert_iterator<_Container>(__x);
}

template <class _Container>
class insert_iterator {
protected:
  _Container* container;
  typename _Container::iterator iter;
public:
  typedef _Container container_type;
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}
  insert_iterator<_Container>&
  operator=(const typename _Container::value_type& __value) {
    iter = container->insert(iter, __value);
    ++iter;
    return *this;
  }
  insert_iterator<_Container>& operator*() { return *this; }
  insert_iterator<_Container>& operator++() { return *this; }
  insert_iterator<_Container>& operator++(int) { return *this; }
};
# 152 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Container, class _Iterator>
inline
insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
{
  typedef typename _Container::iterator __iter;
  return insert_iterator<_Container>(__x, __iter(__i));
}

template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
          class _Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
  typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
                                         _Reference, _Distance> _Self;
protected:
  _BidirectionalIterator current;
public:
  typedef bidirectional_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Distance difference_type;
  typedef _Tp* pointer;
  typedef _Reference reference;

  reverse_bidirectional_iterator() {}
  explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
    : current(__x) {}
  _BidirectionalIterator base() const { return current; }
  _Reference operator*() const {
    _BidirectionalIterator __tmp = current;
    return *--__tmp;
  }

  pointer operator->() const { return &(operator*()); }

  _Self& operator++() {
    --current;
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }
  _Self& operator--() {
    ++current;
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }
};
# 238 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator==(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
{
  return __x.base() == __y.base();
}



template <class _BiIter, class _Tp, class _Ref, class _Distance>
inline bool operator!=(
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
    const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
{
  return !(__x == __y);
}
# 267 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Iterator>
class reverse_iterator
{
protected:
  _Iterator current;
public:
  typedef typename iterator_traits<_Iterator>::iterator_category
          iterator_category;
  typedef typename iterator_traits<_Iterator>::value_type
          value_type;
  typedef typename iterator_traits<_Iterator>::difference_type
          difference_type;
  typedef typename iterator_traits<_Iterator>::pointer
          pointer;
  typedef typename iterator_traits<_Iterator>::reference
          reference;

  typedef _Iterator iterator_type;
  typedef reverse_iterator<_Iterator> _Self;

public:
  reverse_iterator() {}
  explicit reverse_iterator(iterator_type __x) : current(__x) {}

  reverse_iterator(const _Self& __x) : current(__x.current) {}

  template <class _Iter>
  reverse_iterator(const reverse_iterator<_Iter>& __x)
    : current(__x.base()) {}


  iterator_type base() const { return current; }
  reference operator*() const {
    _Iterator __tmp = current;
    return *--__tmp;
  }

  pointer operator->() const { return &(operator*()); }


  _Self& operator++() {
    --current;
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    --current;
    return __tmp;
  }
  _Self& operator--() {
    ++current;
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    ++current;
    return __tmp;
  }

  _Self operator+(difference_type __n) const {
    return _Self(current - __n);
  }
  _Self& operator+=(difference_type __n) {
    current -= __n;
    return *this;
  }
  _Self operator-(difference_type __n) const {
    return _Self(current + __n);
  }
  _Self& operator-=(difference_type __n) {
    current += __n;
    return *this;
  }
  reference operator[](difference_type __n) const { return *(*this + __n); }
};

template <class _Iterator>
inline bool operator==(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return __x.base() == __y.base();
}

template <class _Iterator>
inline bool operator<(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return __y.base() < __x.base();
}



template <class _Iterator>
inline bool operator!=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return !(__x == __y);
}

template <class _Iterator>
inline bool operator>(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return __y < __x;
}

template <class _Iterator>
inline bool operator<=(const reverse_iterator<_Iterator>& __x,
                       const reverse_iterator<_Iterator>& __y) {
  return !(__y < __x);
}

template <class _Iterator>
inline bool operator>=(const reverse_iterator<_Iterator>& __x,
                      const reverse_iterator<_Iterator>& __y) {
  return !(__x < __y);
}



template <class _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
          const reverse_iterator<_Iterator>& __y) {
  return __y.base() - __x.base();
}

template <class _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
          const reverse_iterator<_Iterator>& __x) {
  return reverse_iterator<_Iterator>(__x.base() - __n);
}
# 823 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Tp, class _Dist = ptrdiff_t> class istream_iterator;

template <class _Tp, class _Dist>
inline bool operator==(const istream_iterator<_Tp, _Dist>&,
                       const istream_iterator<_Tp, _Dist>&);

template <class _Tp, class _Dist>
class istream_iterator {

  template <class _T1, class _D1>
  friend bool operator==(const istream_iterator<_T1, _D1>&,
                         const istream_iterator<_T1, _D1>&);






protected:
  istream* _M_stream;
  _Tp _M_value;
  bool _M_end_marker;
  void _M_read() {
    _M_end_marker = (*_M_stream) ? true : false;
    if (_M_end_marker) *_M_stream >> _M_value;
    _M_end_marker = (*_M_stream) ? true : false;
  }
public:
  typedef input_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Dist difference_type;
  typedef const _Tp* pointer;
  typedef const _Tp& reference;

  istream_iterator() : _M_stream(&cin), _M_end_marker(false) {}
  istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }
  reference operator*() const { return _M_value; }

  pointer operator->() const { return &(operator*()); }

  istream_iterator<_Tp, _Dist>& operator++() {
    _M_read();
    return *this;
  }
  istream_iterator<_Tp, _Dist> operator++(int) {
    istream_iterator<_Tp, _Dist> __tmp = *this;
    _M_read();
    return __tmp;
  }
};
# 893 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template <class _Tp, class _Distance>
inline bool operator==(const istream_iterator<_Tp, _Distance>& __x,
                       const istream_iterator<_Tp, _Distance>& __y) {
  return (__x._M_stream == __y._M_stream &&
          __x._M_end_marker == __y._M_end_marker) ||
         __x._M_end_marker == false && __y._M_end_marker == false;
}



template <class _Tp, class _Distance>
inline bool operator!=(const istream_iterator<_Tp, _Distance>& __x,
                       const istream_iterator<_Tp, _Distance>& __y) {
  return !(__x == __y);
}



template <class _Tp>
class ostream_iterator {
protected:
  ostream* _M_stream;
  const char* _M_string;
public:
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  ostream_iterator(ostream& __s) : _M_stream(&__s), _M_string(0) {}
  ostream_iterator(ostream& __s, const char* __c)
    : _M_stream(&__s), _M_string(__c) {}
  ostream_iterator<_Tp>& operator=(const _Tp& __value) {
    *_M_stream << __value;
    if (_M_string) *_M_stream << _M_string;
    return *this;
  }
  ostream_iterator<_Tp>& operator*() { return *this; }
  ostream_iterator<_Tp>& operator++() { return *this; }
  ostream_iterator<_Tp>& operator++(int) { return *this; }
};
# 955 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 3
template<typename _Iterator, typename _Container>
class __normal_iterator
  : public iterator<iterator_traits<_Iterator>::iterator_category,
                    iterator_traits<_Iterator>::value_type,
                    iterator_traits<_Iterator>::difference_type,
                    iterator_traits<_Iterator>::pointer,
                    iterator_traits<_Iterator>::reference>
{

protected:
  _Iterator _M_current;

public:
  typedef __normal_iterator<_Iterator, _Container> normal_iterator_type;
  typedef iterator_traits<_Iterator> __traits_type;
  typedef typename __traits_type::iterator_category iterator_category;
  typedef typename __traits_type::value_type value_type;
  typedef typename __traits_type::difference_type difference_type;
  typedef typename __traits_type::pointer pointer;
  typedef typename __traits_type::reference reference;

  __normal_iterator() : _M_current(_Iterator()) { }

  explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) { }


  template<typename _Iter>
  inline __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
    : _M_current(__i.base()) { }


  reference
  operator*() const { return *_M_current; }

  pointer
  operator->() const { return _M_current; }

  normal_iterator_type&
  operator++() { ++_M_current; return *this; }

  normal_iterator_type
  operator++(int) { return __normal_iterator(_M_current++); }


  normal_iterator_type&
  operator--() { --_M_current; return *this; }

  normal_iterator_type
  operator--(int) { return __normal_iterator(_M_current--); }


  reference
  operator[](const difference_type& __n) const
  { return _M_current[__n]; }

  normal_iterator_type&
  operator+=(const difference_type& __n)
  { _M_current += __n; return *this; }

  normal_iterator_type
  operator+(const difference_type& __n) const
  { return __normal_iterator(_M_current + __n); }

  normal_iterator_type&
  operator-=(const difference_type& __n)
  { _M_current -= __n; return *this; }

  normal_iterator_type
  operator-(const difference_type& __n) const
  { return __normal_iterator(_M_current - __n); }

  difference_type
  operator-(const normal_iterator_type& __i) const
  { return _M_current - __i._M_current; }

  const _Iterator&
  base() const { return _M_current; }
};



template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__lhs == __rhs); }



template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
          const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
          const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return __rhs < __lhs; }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__rhs < __lhs); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
inline bool
operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
           const __normal_iterator<_IteratorR, _Container>& __rhs)
{ return !(__lhs < __rhs); }

template<typename _Iterator, typename _Container>
inline __normal_iterator<_Iterator, _Container>
operator+(__normal_iterator<_Iterator, _Container>::difference_type __n,
          const __normal_iterator<_Iterator, _Container>& __i)
{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

}
# 35 "/opt/gcc3/include/g++-v3/bits/std_iterator.h" 2 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 1 3
# 19 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 20 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 2 3
# 57 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 3
template <bool _Truth> struct _Bool {};
typedef _Bool<true> __true_type;
typedef _Bool<false> __false_type;

template <class _Tp>
struct __type_traits {
   typedef __true_type this_dummy_member_must_be_first;
# 81 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 3
   typedef __false_type has_trivial_default_constructor;
   typedef __false_type has_trivial_copy_constructor;
   typedef __false_type has_trivial_assignment_operator;
   typedef __false_type has_trivial_destructor;
   typedef __false_type is_POD_type;
};
# 96 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 3
template<> struct __type_traits<bool> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template<> struct __type_traits<char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<signed char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned char> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template<> struct __type_traits<wchar_t> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template<> struct __type_traits<short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned short> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned int> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template<> struct __type_traits<long long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<unsigned long long> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template<> struct __type_traits<float> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};

template<> struct __type_traits<long double> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};



template <class _Tp>
struct __type_traits<_Tp*> {
   typedef __true_type has_trivial_default_constructor;
   typedef __true_type has_trivial_copy_constructor;
   typedef __true_type has_trivial_assignment_operator;
   typedef __true_type has_trivial_destructor;
   typedef __true_type is_POD_type;
};
# 301 "/opt/gcc3/include/g++-v3/bits/type_traits.h" 3
template <class _Tp> struct _Is_integer {
  typedef __false_type _Integral;
};



template<> struct _Is_integer<bool> {
  typedef __true_type _Integral;
};



template<> struct _Is_integer<char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<signed char> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned char> {
  typedef __true_type _Integral;
};



template<> struct _Is_integer<wchar_t> {
  typedef __true_type _Integral;
};



template<> struct _Is_integer<short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned short> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned int> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned long> {
  typedef __true_type _Integral;
};



template<> struct _Is_integer<long long> {
  typedef __true_type _Integral;
};

template<> struct _Is_integer<unsigned long long> {
  typedef __true_type _Integral;
};



template<typename _Tp> struct _Is_normal_iterator {
   typedef __false_type _Normal;
};


namespace std {
   template<typename _Iterator, typename _Container> class __normal_iterator;
};

template<typename _Iterator, typename _Container>
struct _Is_normal_iterator< std::__normal_iterator<_Iterator, _Container> > {
   typedef __true_type _Normal;
};
# 42 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 43 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/exception_support.h" 1 3
# 46 "/opt/gcc3/include/g++-v3/bits/exception_support.h" 3
namespace std {



  extern void __out_of_range(const char *__str);
  extern void __length_error(const char *__str);
# 63 "/opt/gcc3/include/g++-v3/bits/exception_support.h" 3
}
# 38 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 2 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/atomicity.h" 1 3
# 23 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/atomicity.h" 3
typedef int _Atomic_word;

static inline _Atomic_word
__attribute__ ((__unused__))
__exchange_and_add (volatile _Atomic_word *__mem, int __val)
{
  register _Atomic_word __result;
  __asm__ __volatile__ ("lock; xaddl %0,%2"
                        : "=r" (__result)
                        : "0" (__val), "m" (*__mem)
                        : "memory");
  return __result;
}

static inline void
__attribute__ ((__unused__))
__atomic_add (volatile _Atomic_word* __mem, int __val)
{
  __asm__ __volatile__ ("lock; addl %0,%1"
                        : : "ir" (__val), "m" (*__mem) : "memory");
}

static inline char
__attribute__ ((__unused__))
__compare_and_swap (volatile long* __p, long __oldval, long __newval)
{
  char __ret;
  long __readval;

  __asm__ __volatile__ ("lock; cmpxchgl %3, %1; sete %0"
                        : "=q" (__ret), "=m" (*__p), "=a" (__readval)
                        : "r" (__newval), "m" (*__p), "a" (__oldval));
  return __ret;
}
# 39 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 2 3

namespace std {
# 81 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {

    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Alloc allocator_type;
      typedef typename _Alloc::size_type size_type;
      typedef typename _Alloc::difference_type difference_type;
      typedef typename _Alloc::reference reference;
      typedef typename _Alloc::const_reference const_reference;
      typedef typename _Alloc::pointer pointer;
      typedef typename _Alloc::const_pointer const_pointer;
      typedef __normal_iterator<pointer, basic_string> iterator;
      typedef __normal_iterator<const_pointer, basic_string> const_iterator;
      typedef reverse_iterator<const_iterator> const_reverse_iterator;
      typedef reverse_iterator<iterator> reverse_iterator;

    private:
# 116 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 3
      struct _Rep
      {

        typedef typename _Alloc::rebind<char>::other _Raw_bytes_alloc;
# 134 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 3
        static const size_type _S_max_size;
        static const _CharT _S_terminal;

        size_type _M_length;
        size_type _M_capacity;
        _Atomic_word _M_references;

        bool
        _M_is_leaked() const
        { return _M_references < 0; }

        bool
        _M_is_shared() const
        { return _M_references > 0; }

        void
        _M_set_leaked()
        { _M_references = -1; }

        void
        _M_set_sharable()
        { _M_references = 0; }

        _CharT*
        _M_refdata() throw()
        { return reinterpret_cast<_CharT*> (this + 1); }

        _CharT&
        operator[](size_t __s) throw()
        { return _M_refdata() [__s]; }

        _CharT*
        _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
        { return (!_M_is_leaked() && __alloc1 == __alloc2) ?
            _M_refcopy() : _M_clone(__alloc1); }


        static _Rep*
        _S_create(size_t, const _Alloc&);

        void
        _M_dispose(const _Alloc& __a)
        {
          if (__exchange_and_add(&_M_references, -1) <= 0)
            _M_destroy(__a);
        }

        void
        _M_destroy(const _Alloc&) throw();

        _CharT*
        _M_refcopy() throw()
        {
          __atomic_add(&_M_references, 1);
          return _M_refdata();
        }

        _CharT*
        _M_clone(const _Alloc&, size_type __res = 0);
# 206 "/opt/gcc3/include/g++-v3/bits/basic_string.h" 3
        inline static bool
        _S_excess_slop(size_t, size_t);

      };


      struct _Alloc_hider : _Alloc
      {
        _Alloc_hider(_CharT* __dat, const _Alloc& __a)
        : _Alloc(__a), _M_p(__dat) { }

        _CharT* _M_p;
      };

    public:



      static const size_type npos = static_cast<size_type>(-1);

    private:

      mutable _Alloc_hider _M_dataplus;



      static size_type _S_empty_rep_storage[(sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];

      _CharT*
      _M_data() const
      { return _M_dataplus._M_p; }

      _CharT*
      _M_data(_CharT* __p)
      { return (_M_dataplus._M_p = __p); }

      _Rep*
      _M_rep() const
      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }



      iterator
      _M_ibegin() const { return iterator(_M_data()); }

      iterator
      _M_iend() const { return iterator(_M_data() + this->size()); }

      void
      _M_leak()
      {
        if (!_M_rep()->_M_is_leaked())
          _M_leak_hard();
      }

      iterator
      _M_check(size_type __pos) const
      {
        do { if (__pos > this->size()) __out_of_range("__pos > this->size()"); } while (0);
        return _M_ibegin() + __pos;
      }


      iterator
      _M_fold(size_type __pos, size_type __off) const
      {
        bool __testoff = __off < this->size() - __pos;
        size_type __newoff = __testoff ? __off : this->size() - __pos;
        return (_M_ibegin() + __pos + __newoff);
      }



      template<class _Iterator>
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
          for (; __k1 != __k2; ++__k1, ++__p)
            traits_type::assign(*__p, *__k1);
        }

      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      { traits_type::copy(__p, __k1, __k2 - __k1); }

      void
      _M_mutate(size_type __pos, size_type __len1, size_type __len2);

      void
      _M_leak_hard();

      static _Rep&
      _S_empty_rep()
      { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }

    public:




      inline
      basic_string();

      explicit
      basic_string(const _Alloc& __a);


      basic_string(const basic_string& __str);
      basic_string(const basic_string& __str, size_type __pos,
                   size_type __n = npos);
      basic_string(const basic_string& __str, size_type __pos,
                   size_type __n, const _Alloc& __a);

      basic_string(const _CharT* __s, size_type __n,
                   const _Alloc& __a = _Alloc());
      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());

      template<class _InputIterator>
        basic_string(_InputIterator __begin, _InputIterator __end,
                     const _Alloc& __a = _Alloc());

      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }

      basic_string&
      operator=(const basic_string& __str) { return this->assign(__str); }

      basic_string&
      operator=(const _CharT* __s) { return this->assign(__s); }

      basic_string&
      operator=(_CharT __c) { return this->assign(1, __c); }


      iterator
      begin()
      {
        _M_leak();
        return iterator(_M_data());
      }

      const_iterator
      begin() const
      { return const_iterator(_M_data()); }

      iterator
      end()
      {
         _M_leak();
         return iterator(_M_data() + this->size());
      }

      const_iterator
      end() const
      { return const_iterator(_M_data() + this->size()); }

      reverse_iterator
      rbegin()
      { return reverse_iterator(this->end()); }

      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(this->end()); }

      reverse_iterator
      rend()
      { return reverse_iterator(this->begin()); }

      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(this->begin()); }

    public:

      size_type
      size() const { return _M_rep()->_M_length; }

      size_type
      length() const { return _M_rep()->_M_length; }

      size_type
      max_size() const { return _Rep::_S_max_size; }

      void
      resize(size_type __n, _CharT __c);

      void
      resize(size_type __n) { this->resize(__n, _CharT()); }

      size_type
      capacity() const { return _M_rep()->_M_capacity; }

      void
      reserve(size_type __res_arg = 0);

      void
      clear() { _M_mutate(0, this->size(), 0); }

      bool
      empty() const { return this->size() == 0; }


      const_reference
      operator[] (size_type __pos) const
      { return _M_data()[__pos]; }

      reference
      operator[](size_type __pos)
      {
        _M_leak();
        return _M_data()[__pos];
      }

      const_reference
      at(size_type __n) const
      {
        do { if (__n >= this->size()) __out_of_range("__n >= this->size()"); } while (0);
        return _M_data()[__n];
      }

      reference
      at(size_type __n)
      {
        do { if (__n >= size()) __out_of_range("__n >= size()"); } while (0);
        _M_leak();
        return _M_data()[__n];
      }


      basic_string&
      operator+=(const basic_string& __str) { return this->append(__str); }

      basic_string&
      operator+=(const _CharT* __s) { return this->append(__s); }

      basic_string&
      operator+=(_CharT __c) { return this->append(size_type(1), __c); }

      basic_string&
      append(const basic_string& __str);

      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n);

      basic_string&
      append(const _CharT* __s, size_type __n);

      basic_string&
      append(const _CharT* __s)
      { return this->append(__s, traits_type::length(__s)); }

      basic_string&
      append(size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_iend(), _M_iend(), __first, __last); }

      void
      push_back(_CharT __c)
      { this->replace(_M_iend(), _M_iend(), 1, __c); }

      basic_string&
      assign(const basic_string& __str);

      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n)
      {
        return this->assign(__str._M_check(__pos), __str._M_fold(__pos, __n));
      }

      basic_string&
      assign(const _CharT* __s, size_type __n)
      { return this->assign(__s, __s + __n); }

      basic_string&
      assign(const _CharT* __s)
      { return this->assign(__s, __s + traits_type::length(__s)); }

      basic_string&
      assign(size_type __n, _CharT __c)
      { return this->replace(_M_ibegin(), _M_iend(), __n, __c); }

      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }

      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }

      template<class _InputIterator>
        void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }

      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      {
        iterator __p = _M_check(__pos1);
        this->replace(__p, __p, __str._M_ibegin(), __str._M_iend());
        return *this;
      }

      basic_string&
      insert(size_type __pos1, const basic_string& __str,
             size_type __pos2, size_type __n)
      {
        iterator __p = _M_check(__pos1);
        this->replace(__p, __p, __str._M_check(__pos2),
                      __str._M_fold(__pos2, __n));
        return *this;
      }

      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n)
      {
        iterator __p = _M_check(__pos);
        this->replace(__p, __p, __s, __s + __n);
        return *this;
      }

      basic_string&
      insert(size_type __pos, const _CharT* __s)
      { return this->insert(__pos, __s, traits_type::length(__s)); }

      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      {
        this->insert(_M_check(__pos), __n, __c);
        return *this;
      }

      iterator
      insert(iterator __p, _CharT __c = _CharT())
      {
        size_type __pos = __p - _M_ibegin();
        this->insert(_M_check(__pos), size_type(1), __c);
        _M_rep()->_M_set_leaked();
        return this->_M_ibegin() + __pos;
      }

      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n),
                             _M_data(), _M_data());
      }

      iterator
      erase(iterator __position)
      {
        size_type __i = __position - _M_ibegin();
        this->replace(__position, __position + 1, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
        return _M_ibegin() + __i;
      }

      iterator
      erase(iterator __first, iterator __last)
      {
        size_type __i = __first - _M_ibegin();
        this->replace(__first, __last, _M_data(), _M_data());
        _M_rep()->_M_set_leaked();
       return _M_ibegin() + __i;
      }

      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n),
                              __str.begin(), __str.end());
      }

      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2);

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1),
                             __s, __s + __n2);
      }

      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1),
                             __s, __s + traits_type::length(__s));
      }

      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      {
        return this->replace(_M_check(__pos), _M_fold(__pos, __n1), __n2, __c);
      }

      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str.begin(), __str.end()); }

      basic_string&
      replace(iterator __i1, iterator __i2,
                           const _CharT* __s, size_type __n)
      { return this->replace(__i1, __i2, __s, __s + __n); }

      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      { return this->replace(__i1, __i2, __s,
                             __s + traits_type::length(__s)); }

      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c);

      template<class _InputIterator>
        basic_string&
        replace(iterator __i1, iterator __i2,
                _InputIterator __k1, _InputIterator __k2)
        { return _M_replace(__i1, __i2, __k1, __k2,
             typename iterator_traits<_InputIterator>::iterator_category()); }

    private:
      template<class _InputIterator>
        basic_string&
        _M_replace(iterator __i1, iterator __i2, _InputIterator __k1,
                   _InputIterator __k2, input_iterator_tag);

      template<class _FwdIterator>
        basic_string&
        _M_replace(iterator __i1, iterator __i2, _FwdIterator __k1,
                   _FwdIterator __k2, forward_iterator_tag);



      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __false_type)
        {
          typedef typename iterator_traits<_InIter>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
        }

      template<class _InIter>
        static _CharT*
        _S_construct_aux(_InIter __beg, _InIter __end, const _Alloc& __a,
                         __true_type)
        {
          return _S_construct(static_cast<size_type>(__beg),
                              static_cast<value_type>(__end), __a);
        }

      template<class _InIter>
        static _CharT*
        _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a)
        {
          typedef typename _Is_integer<_InIter>::_Integral _Integral;
          return _S_construct_aux(__beg, __end, __a, _Integral());
        }


      template<class _InIter>
        static _CharT*
         _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                      input_iterator_tag);



      template<class _FwdIter>
        static _CharT*
        _S_construct(_FwdIter __end, _FwdIter __beg, const _Alloc& __a,
                     forward_iterator_tag);

      static _CharT*
      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);

    public:

      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;

      void
      swap(basic_string<_CharT, _Traits, _Alloc>& __s);


      const _CharT*
      c_str() const
      {

        size_type __n = this->size();
        traits_type::assign(_M_data()[__n], _Rep::_S_terminal);
        return _M_data();
      }

      const _CharT*
      data() const { return _M_data(); }

      allocator_type
      get_allocator() const { return _M_dataplus; }

      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      { return this->find(__str.data(), __pos, __str.size()); }

      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      { return this->find(__s, __pos, traits_type::length(__s)); }

      size_type
      find(_CharT __c, size_type __pos = 0) const;

      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      { return this->rfind(__str.data(), __pos, __str.size()); }

      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      { return this->rfind(__s, __pos, traits_type::length(__s)); }

      size_type
      rfind(_CharT __c, size_type __pos = npos) const;

      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }

      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;

      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }

      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
                        size_type __n) const;

      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      { return this->find_first_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;

      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }

      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
                       size_type __n) const;
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      { return this->find_last_not_of(__s, __pos, traits_type::length(__s)); }

      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;

      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      {
        do { if (__pos > this->size()) __out_of_range("__pos > this->size()"); } while (0);
        return basic_string(*this, __pos, __n);
      }

      int
      compare(const basic_string& __str) const
      {
        size_type __size = this->size();
        size_type __osize = __str.size();
        size_type __len = min(__size, __osize);

        int __r = traits_type::compare(_M_data(), __str.data(), __len);
        if (!__r)
          __r = __size - __osize;
        return __r;
      }

      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;

      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
              size_type __pos2, size_type __n2) const;

      int
      compare(const _CharT* __s) const;

      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
              size_type __n2 = npos) const;
  };


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()
    : _M_dataplus(_S_empty_rep()._M_refcopy(), _Alloc()) { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
              const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
             const _CharT* __rhs)
    {
      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str(__lhs);
      __str.append(__size_type(1), __rhs);
      return __str;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) == 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) == 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) == 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) != 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) != 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) != 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) < 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const _CharT* __rhs)
    { return __lhs.compare(__rhs) < 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<(const _CharT* __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) > 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) > 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
              const _CharT* __rhs)
    { return __lhs.compare(__rhs) > 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>(const _CharT* __lhs,
              const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) < 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) <= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) <= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator<=(const _CharT* __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
  { return __rhs.compare(__lhs) >= 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __lhs.compare(__rhs) >= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
               const _CharT* __rhs)
    { return __lhs.compare(__rhs) >= 0; }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator>=(const _CharT* __lhs,
             const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) <= 0; }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
         basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { __lhs.swap(__rhs); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
               basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
               const basic_string<_CharT, _Traits, _Alloc>& __str);

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
            basic_string<_CharT, _Traits, _Alloc>& __str);

}
# 44 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3


# 1 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 1 3
# 30 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 36 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3

# 1 "/opt/gcc3/include/g++-v3/bits/stl_pair.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_pair.h" 3
namespace std {

template <class _T1, class _T2>
struct pair {
  typedef _T1 first_type;
  typedef _T2 second_type;

  _T1 first;
  _T2 second;
  pair() : first(_T1()), second(_T2()) {}
  pair(const _T1& __a, const _T2& __b) : first(__a), second(__b) {}


  template <class _U1, class _U2>
  pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}

};

template <class _T1, class _T2>
inline bool operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
  return __x.first == __y.first && __x.second == __y.second;
}

template <class _T1, class _T2>
inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
{
  return __x.first < __y.first ||
         (!(__y.first < __x.first) && __x.second < __y.second);
}



template <class _T1, class _T2>
inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__x == __y);
}

template <class _T1, class _T2>
inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return __y < __x;
}

template <class _T1, class _T2>
inline bool operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__y < __x);
}

template <class _T1, class _T2>
inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) {
  return !(__x < __y);
}



template <class _T1, class _T2>


inline pair<_T1, _T2> make_pair(const _T1 __x, const _T2 __y)



{
  return pair<_T1, _T2>(__x, __y);
}

}
# 38 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3




# 1 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 1 3
# 43 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_climits.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_climits.h" 3
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 1 3 4
# 11 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/syslimits.h" 1 3 4






# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 1 3 4
# 130 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 126 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 27 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 28 "/usr/include/bits/local_lim.h" 2 3 4
# 127 "/usr/include/bits/posix1_lim.h" 2 3 4
# 31 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 35 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 39 "/usr/include/limits.h" 2 3 4
# 131 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 2 3 4
# 8 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/syslimits.h" 2 3 4
# 12 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 2 3 4
# 41 "/opt/gcc3/include/g++-v3/bits/std_climits.h" 2 3
# 44 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 1 3
# 45 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 46 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/new" 1 3
# 47 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3




# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 52 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3


# 1 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 1 3
# 55 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_iterator.h" 1 3
# 56 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 2 3



namespace std {



template <class _ForwardIter1, class _ForwardIter2, class _Tp>
inline void __iter_swap(_ForwardIter1 __a, _ForwardIter2 __b, _Tp*) {
  _Tp __tmp = *__a;
  *__a = *__b;
  *__b = __tmp;
}

template <class _ForwardIter1, class _ForwardIter2>
inline void iter_swap(_ForwardIter1 __a, _ForwardIter2 __b) {
  do { void (*__x)( _ForwardIter1 ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter1 > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter2 > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter1>::value_type , typename iterator_traits<_ForwardIter2>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_ForwardIter1>::value_type , typename iterator_traits<_ForwardIter2>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_ForwardIter2>::value_type , typename iterator_traits<_ForwardIter1>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_ForwardIter2>::value_type , typename iterator_traits<_ForwardIter1>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  __iter_swap(__a, __b, __value_type(__a));
}

template <class _Tp>
inline void swap(_Tp& __a, _Tp& __b) {
  do { void (*__x)( _Tp ) = _Assignable_concept_specification< _Tp > ::_Assignable_requirement_violation; __x = __x; } while (0);
  _Tp __tmp = __a;
  __a = __b;
  __b = __tmp;
}
# 97 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
template <class _Tp>
inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__b < __a) return __b; return __a;
}

template <class _Tp>
inline const _Tp& max(const _Tp& __a, const _Tp& __b) {
  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__a < __b) return __b; return __a;
}



template <class _Tp, class _Compare>
inline const _Tp& min(const _Tp& __a, const _Tp& __b, _Compare __comp) {

  if (__comp(__b, __a)) return __b; return __a;
}

template <class _Tp, class _Compare>
inline const _Tp& max(const _Tp& __a, const _Tp& __b, _Compare __comp) {

  if (__comp(__a, __b)) return __b; return __a;
}
# 134 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
template <class _InputIter, class _OutputIter, class _Distance>
inline _OutputIter __copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result,
                          input_iterator_tag, _Distance*)
{
  for ( ; __first != __last; ++__result, ++__first)
    *__result = *__first;
  return __result;
}

template <class _RandomAccessIter, class _OutputIter, class _Distance>
inline _OutputIter
__copy(_RandomAccessIter __first, _RandomAccessIter __last,
       _OutputIter __result, random_access_iterator_tag, _Distance*)
{
  for (_Distance __n = __last - __first; __n > 0; --__n) {
    *__result = *__first;
    ++__first;
    ++__result;
  }
  return __result;
}

template <class _Tp>
inline _Tp*
__copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result) {
  memmove(__result, __first, sizeof(_Tp) * (__last - __first));
  return __result + (__last - __first);
}



template <class _InputIter, class _OutputIter>
inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __false_type) {
  return __copy(__first, __last, __result,
                __iterator_category(__first),
                __distance_type(__first));
}

template <class _InputIter, class _OutputIter>
inline _OutputIter __copy_aux2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type) {
  return __copy(__first, __last, __result,
                __iterator_category(__first),
                __distance_type(__first));
}



template <class _Tp>
inline _Tp* __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result,
                        __true_type) {
  return __copy_trivial(__first, __last, __result);
}



template <class _Tp>
inline _Tp* __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result,
                        __true_type) {
  return __copy_trivial(__first, __last, __result);
}


template <class _InputIter, class _OutputIter, class _Tp>
inline _OutputIter __copy_aux(_InputIter __first, _InputIter __last,
                              _OutputIter __result, _Tp*) {
  typedef typename __type_traits<_Tp>::has_trivial_assignment_operator
          _Trivial;
  return __copy_aux2(__first, __last, __result, _Trivial());
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type) {
  return _OutputIter(__copy_aux(__first, __last, __result.base(),
                                __value_type(__first)));
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni2(_InputIter __first, _InputIter __last,
                              _OutputIter __result, __false_type) {
  return __copy_aux(__first, __last, __result, __value_type(__first));
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __true_type) {
  typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
  return __copy_ni2(__first.base(), __last.base(), __result, __Normal());
}

template<typename _InputIter, typename _OutputIter>
inline _OutputIter __copy_ni1(_InputIter __first, _InputIter __last,
                               _OutputIter __result, __false_type) {
  typedef typename _Is_normal_iterator<_OutputIter>::_Normal __Normal;
  return __copy_ni2(__first, __last, __result, __Normal());
}

template <class _InputIter, class _OutputIter>
inline _OutputIter copy(_InputIter __first, _InputIter __last,
                        _OutputIter __result) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
   typedef typename _Is_normal_iterator<_InputIter>::_Normal __Normal;
   return __copy_ni1(__first, __last, __result, __Normal());
}
# 331 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _Distance>
inline _BidirectionalIter2 __copy_backward(_BidirectionalIter1 __first,
                                           _BidirectionalIter1 __last,
                                           _BidirectionalIter2 __result,
                                           bidirectional_iterator_tag,
                                           _Distance*)
{
  while (__first != __last)
    *--__result = *--__last;
  return __result;
}

template <class _RandomAccessIter, class _BidirectionalIter, class _Distance>
inline _BidirectionalIter __copy_backward(_RandomAccessIter __first,
                                          _RandomAccessIter __last,
                                          _BidirectionalIter __result,
                                          random_access_iterator_tag,
                                          _Distance*)
{
  for (_Distance __n = __last - __first; __n > 0; --__n)
    *--__result = *--__last;
  return __result;
}
# 363 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BoolType>
struct __copy_backward_dispatch
{
  typedef typename iterator_traits<_BidirectionalIter1>::iterator_category
          _Cat;
  typedef typename iterator_traits<_BidirectionalIter1>::difference_type
          _Distance;

  static _BidirectionalIter2 copy(_BidirectionalIter1 __first,
                                  _BidirectionalIter1 __last,
                                  _BidirectionalIter2 __result) {
    return __copy_backward(__first, __last, __result, _Cat(), (_Distance*) 0);
  }
};

template <class _Tp>
struct __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
{
  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
    const ptrdiff_t _Num = __last - __first;
    memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
    return __result - _Num;
  }
};

template <class _Tp>
struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
{
  static _Tp* copy(const _Tp* __first, const _Tp* __last, _Tp* __result) {
    return __copy_backward_dispatch<_Tp*, _Tp*, __true_type>
      ::copy(__first, __last, __result);
  }
};

template <class _BI1, class _BI2>
inline _BI2 __copy_backward_aux(_BI1 __first, _BI1 __last, _BI2 __result) {
  typedef typename __type_traits<typename iterator_traits<_BI2>::value_type>
                        ::has_trivial_assignment_operator
          _Trivial;
  return __copy_backward_dispatch<_BI1, _BI2, _Trivial>
              ::copy(__first, __last, __result);
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                                   _BI2 __result, __true_type) {
  return _BI2(__copy_backward_aux(__first, __last, __result.base()));
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_output_normal_iterator(_BI1 __first, _BI1 __last,
                                                   _BI2 __result, __false_type){
  return __copy_backward_aux(__first, __last, __result);
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                                  _BI2 __result, __true_type) {
  typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
  return __copy_backward_output_normal_iterator(__first.base(), __last.base(),
                                                __result, __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 __copy_backward_input_normal_iterator(_BI1 __first, _BI1 __last,
                                                  _BI2 __result, __false_type) {
  typedef typename _Is_normal_iterator<_BI2>::_Normal __Normal;
  return __copy_backward_output_normal_iterator(__first, __last, __result,
                                                __Normal());
}

template <typename _BI1, typename _BI2>
inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {
  do { void (*__x)( _BI1 ) = _BidirectionalIterator_concept_specification< _BI1 > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _BI2 ) = _Mutable_BidirectionalIterator_concept_specification< _BI2 > ::_Mutable_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_BI1>::value_type , typename iterator_traits<_BI2>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_BI1>::value_type , typename iterator_traits<_BI2>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
  return __copy_backward_input_normal_iterator(__first, __last, __result,
                                               __Normal());
}
# 460 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 3
template <class _InputIter, class _Size, class _OutputIter>
pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count,
                                       _OutputIter __result,
                                       input_iterator_tag) {
  for ( ; __count > 0; --__count) {
    *__result = *__first;
    ++__first;
    ++__result;
  }
  return pair<_InputIter, _OutputIter>(__first, __result);
}

template <class _RAIter, class _Size, class _OutputIter>
inline pair<_RAIter, _OutputIter>
__copy_n(_RAIter __first, _Size __count,
         _OutputIter __result,
         random_access_iterator_tag) {
  _RAIter __last = __first + __count;
  return pair<_RAIter, _OutputIter>(__last, copy(__first, __last, __result));
}

template <class _InputIter, class _Size, class _OutputIter>
inline pair<_InputIter, _OutputIter>
__copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
  return __copy_n(__first, __count, __result,
                  __iterator_category(__first));
}

template <class _InputIter, class _Size, class _OutputIter>
inline pair<_InputIter, _OutputIter>
copy_n(_InputIter __first, _Size __count, _OutputIter __result) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  return __copy_n(__first, __count, __result);
}





template <class _ForwardIter, class _Tp>
void fill(_ForwardIter __first, _ForwardIter __last, const _Tp& __value) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __first != __last; ++__first)
    *__first = __value;
}

template <class _OutputIter, class _Size, class _Tp>
_OutputIter fill_n(_OutputIter __first, _Size __n, const _Tp& __value) {
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __n > 0; --__n, ++__first)
    *__first = __value;
  return __first;
}



inline void fill(unsigned char* __first, unsigned char* __last,
                 const unsigned char& __c) {
  unsigned char __tmp = __c;
  memset(__first, __tmp, __last - __first);
}

inline void fill(signed char* __first, signed char* __last,
                 const signed char& __c) {
  signed char __tmp = __c;
  memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
}

inline void fill(char* __first, char* __last, const char& __c) {
  char __tmp = __c;
  memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
}



template <class _Size>
inline unsigned char* fill_n(unsigned char* __first, _Size __n,
                             const unsigned char& __c) {
  fill(__first, __first + __n, __c);
  return __first + __n;
}

template <class _Size>
inline signed char* fill_n(char* __first, _Size __n,
                           const signed char& __c) {
  fill(__first, __first + __n, __c);
  return __first + __n;
}

template <class _Size>
inline char* fill_n(char* __first, _Size __n, const char& __c) {
  fill(__first, __first + __n, __c);
  return __first + __n;
}






template <class _InputIter1, class _InputIter2>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
                                        _InputIter1 __last1,
                                        _InputIter2 __first2) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_InputIter2>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter2>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && *__first1 == *__first2) {
    ++__first1;
    ++__first2;
  }
  return pair<_InputIter1, _InputIter2>(__first1, __first2);
}

template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
                                        _InputIter1 __last1,
                                        _InputIter2 __first2,
                                        _BinaryPredicate __binary_pred) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  while (__first1 != __last1 && __binary_pred(*__first1, *__first2)) {
    ++__first1;
    ++__first2;
  }
  return pair<_InputIter1, _InputIter2>(__first1, __first2);
}

template <class _InputIter1, class _InputIter2>
inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_InputIter2>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter2>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  for ( ; __first1 != __last1; ++__first1, ++__first2)
    if (*__first1 != *__first2)
      return false;
  return true;
}

template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
inline bool equal(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _BinaryPredicate __binary_pred) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __first1 != __last1; ++__first1, ++__first2)
    if (!__binary_pred(*__first1, *__first2))
      return false;
  return true;
}





template <class _InputIter1, class _InputIter2>
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_InputIter2>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter2>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  for ( ; __first1 != __last1 && __first2 != __last2
        ; ++__first1, ++__first2) {
    if (*__first1 < *__first2)
      return true;
    if (*__first2 < *__first1)
      return false;
  }
  return __first1 == __last1 && __first2 != __last2;
}

template <class _InputIter1, class _InputIter2, class _Compare>
bool lexicographical_compare(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __first1 != __last1 && __first2 != __last2
        ; ++__first1, ++__first2) {
    if (__comp(*__first1, *__first2))
      return true;
    if (__comp(*__first2, *__first1))
      return false;
  }
  return __first1 == __last1 && __first2 != __last2;
}

inline bool
lexicographical_compare(const unsigned char* __first1,
                        const unsigned char* __last1,
                        const unsigned char* __first2,
                        const unsigned char* __last2)
{
  const size_t __len1 = __last1 - __first1;
  const size_t __len2 = __last2 - __first2;
  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
  return __result != 0 ? __result < 0 : __len1 < __len2;
}

inline bool lexicographical_compare(const char* __first1, const char* __last1,
                                    const char* __first2, const char* __last2)
{

  return lexicographical_compare((const signed char*) __first1,
                                 (const signed char*) __last1,
                                 (const signed char*) __first2,
                                 (const signed char*) __last2);






}

template <class _InputIter1, class _InputIter2>
int __lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
                                   _InputIter2 __first2, _InputIter2 __last2)
{
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2)
      return -1;
    if (*__first2 < *__first1)
      return 1;
    ++__first1;
    ++__first2;
  }
  if (__first2 == __last2) {
    return !(__first1 == __last1);
  }
  else {
    return -1;
  }
}

inline int
__lexicographical_compare_3way(const unsigned char* __first1,
                               const unsigned char* __last1,
                               const unsigned char* __first2,
                               const unsigned char* __last2)
{
  const ptrdiff_t __len1 = __last1 - __first1;
  const ptrdiff_t __len2 = __last2 - __first2;
  const int __result = memcmp(__first1, __first2, min(__len1, __len2));
  return __result != 0 ? __result
                       : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
}

inline int
__lexicographical_compare_3way(const char* __first1, const char* __last1,
                               const char* __first2, const char* __last2)
{

  return __lexicographical_compare_3way(
                                (const signed char*) __first1,
                                (const signed char*) __last1,
                                (const signed char*) __first2,
                                (const signed char*) __last2);






}

template <class _InputIter1, class _InputIter2>
int lexicographical_compare_3way(_InputIter1 __first1, _InputIter1 __last1,
                                 _InputIter2 __first2, _InputIter2 __last2)
{
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_InputIter2>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter2>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  return __lexicographical_compare_3way(__first1, __last1, __first2, __last2);
}

}
# 31 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 3
# 1 "/opt/gcc3/include/g++-v3/new" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 2 3

namespace std {
# 46 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 3
template <class _T1, class _T2>
inline void _Construct(_T1* __p, const _T2& __value) {
new ((void*) __p) _T1(__value);
}

template <class _T1>
inline void _Construct(_T1* __p) {
  new ((void*) __p) _T1();
}

template <class _Tp>
inline void _Destroy(_Tp* __pointer) {
  __pointer->~_Tp();
}

template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
  for ( ; __first != __last; ++__first)
    destroy(&*__first);
}

template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}

template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
  typedef typename __type_traits<_Tp>::has_trivial_destructor
          _Trivial_destructor;
  __destroy_aux(__first, __last, _Trivial_destructor());
}

template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
  __destroy(__first, __last, __value_type(__first));
}

inline void _Destroy(char*, char*) {}
inline void _Destroy(int*, int*) {}
inline void _Destroy(long*, long*) {}
inline void _Destroy(float*, float*) {}
inline void _Destroy(double*, double*) {}

inline void _Destroy(wchar_t*, wchar_t*) {}





template <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __value) {
  _Construct(__p, __value);
}

template <class _T1>
inline void construct(_T1* __p) {
  _Construct(__p);
}

template <class _Tp>
inline void destroy(_Tp* __pointer) {
  _Destroy(__pointer);
}

template <class _ForwardIterator>
inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
  _Destroy(__first, __last);
}

}
# 32 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstring.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 2 3

namespace std {





template <class _InputIter, class _ForwardIter>
inline _ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                         _ForwardIter __result,
                         __true_type)
{
  return copy(__first, __last, __result);
}

template <class _InputIter, class _ForwardIter>
_ForwardIter
__uninitialized_copy_aux(_InputIter __first, _InputIter __last,
                         _ForwardIter __result,
                         __false_type)
{
  _ForwardIter __cur = __result;
  try {
    for ( ; __first != __last; ++__first, ++__cur)
      _Construct(&*__cur, *__first);
    return __cur;
  }
  catch(...) { _Destroy(__result, __cur); throw; };
}


template <class _InputIter, class _ForwardIter, class _Tp>
inline _ForwardIter
__uninitialized_copy(_InputIter __first, _InputIter __last,
                     _ForwardIter __result, _Tp*)
{
  typedef typename __type_traits<_Tp>::is_POD_type _Is_POD;
  return __uninitialized_copy_aux(__first, __last, __result, _Is_POD());
}

template <class _InputIter, class _ForwardIter>
inline _ForwardIter
  uninitialized_copy(_InputIter __first, _InputIter __last,
                     _ForwardIter __result)
{
  return __uninitialized_copy(__first, __last, __result,
                              __value_type(__result));
}

inline char* uninitialized_copy(const char* __first, const char* __last,
                                char* __result) {
  memmove(__result, __first, __last - __first);
  return __result + (__last - __first);
}

inline wchar_t*
uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
                   wchar_t* __result)
{
  memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
  return __result + (__last - __first);
}



template <class _InputIter, class _Size, class _ForwardIter>
pair<_InputIter, _ForwardIter>
__uninitialized_copy_n(_InputIter __first, _Size __count,
                       _ForwardIter __result,
                       input_iterator_tag)
{
  _ForwardIter __cur = __result;
  try {
    for ( ; __count > 0 ; --__count, ++__first, ++__cur)
      _Construct(&*__cur, *__first);
    return pair<_InputIter, _ForwardIter>(__first, __cur);
  }
  catch(...) { _Destroy(__result, __cur); throw; };
}

template <class _RandomAccessIter, class _Size, class _ForwardIter>
inline pair<_RandomAccessIter, _ForwardIter>
__uninitialized_copy_n(_RandomAccessIter __first, _Size __count,
                       _ForwardIter __result,
                       random_access_iterator_tag) {
  _RandomAccessIter __last = __first + __count;
  return pair<_RandomAccessIter, _ForwardIter>(
                 __last,
                 uninitialized_copy(__first, __last, __result));
}

template <class _InputIter, class _Size, class _ForwardIter>
inline pair<_InputIter, _ForwardIter>
__uninitialized_copy_n(_InputIter __first, _Size __count,
                     _ForwardIter __result) {
  return __uninitialized_copy_n(__first, __count, __result,
                                __iterator_category(__first));
}

template <class _InputIter, class _Size, class _ForwardIter>
inline pair<_InputIter, _ForwardIter>
uninitialized_copy_n(_InputIter __first, _Size __count,
                     _ForwardIter __result) {
  return __uninitialized_copy_n(__first, __count, __result,
                                __iterator_category(__first));
}



template <class _ForwardIter, class _Tp>
inline void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
                         const _Tp& __x, __true_type)
{
  fill(__first, __last, __x);
}

template <class _ForwardIter, class _Tp>
void
__uninitialized_fill_aux(_ForwardIter __first, _ForwardIter __last,
                         const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  try {
    for ( ; __cur != __last; ++__cur)
      _Construct(&*__cur, __x);
  }
  catch(...) { _Destroy(__first, __cur); throw; };
}

template <class _ForwardIter, class _Tp, class _Tp1>
inline void __uninitialized_fill(_ForwardIter __first,
                                 _ForwardIter __last, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  __uninitialized_fill_aux(__first, __last, __x, _Is_POD());

}

template <class _ForwardIter, class _Tp>
inline void uninitialized_fill(_ForwardIter __first,
                               _ForwardIter __last,
                               const _Tp& __x)
{
  __uninitialized_fill(__first, __last, __x, __value_type(__first));
}



template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                           const _Tp& __x, __true_type)
{
  return fill_n(__first, __n, __x);
}

template <class _ForwardIter, class _Size, class _Tp>
_ForwardIter
__uninitialized_fill_n_aux(_ForwardIter __first, _Size __n,
                           const _Tp& __x, __false_type)
{
  _ForwardIter __cur = __first;
  try {
    for ( ; __n > 0; --__n, ++__cur)
      _Construct(&*__cur, __x);
    return __cur;
  }
  catch(...) { _Destroy(__first, __cur); throw; };
}

template <class _ForwardIter, class _Size, class _Tp, class _Tp1>
inline _ForwardIter
__uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x, _Tp1*)
{
  typedef typename __type_traits<_Tp1>::is_POD_type _Is_POD;
  return __uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
}

template <class _ForwardIter, class _Size, class _Tp>
inline _ForwardIter
uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
{
  return __uninitialized_fill_n(__first, __n, __x, __value_type(__first));
}
# 230 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 3
template <class _InputIter1, class _InputIter2, class _ForwardIter>
inline _ForwardIter
__uninitialized_copy_copy(_InputIter1 __first1, _InputIter1 __last1,
                          _InputIter2 __first2, _InputIter2 __last2,
                          _ForwardIter __result)
{
  _ForwardIter __mid = uninitialized_copy(__first1, __last1, __result);
  try {
    return uninitialized_copy(__first2, __last2, __mid);
  }
  catch(...) { _Destroy(__result, __mid); throw; };
}




template <class _ForwardIter, class _Tp, class _InputIter>
inline _ForwardIter
__uninitialized_fill_copy(_ForwardIter __result, _ForwardIter __mid,
                          const _Tp& __x,
                          _InputIter __first, _InputIter __last)
{
  uninitialized_fill(__result, __mid, __x);
  try {
    return uninitialized_copy(__first, __last, __mid);
  }
  catch(...) { _Destroy(__result, __mid); throw; };
}




template <class _InputIter, class _ForwardIter, class _Tp>
inline void
__uninitialized_copy_fill(_InputIter __first1, _InputIter __last1,
                          _ForwardIter __first2, _ForwardIter __last2,
                          const _Tp& __x)
{
  _ForwardIter __mid2 = uninitialized_copy(__first1, __last1, __first2);
  try {
    uninitialized_fill(__mid2, __last2, __x);
  }
  catch(...) { _Destroy(__first2, __mid2); throw; };
}

}
# 33 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_tempbuf.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_tempbuf.h" 3
namespace std {

template <class _Tp>
pair<_Tp*, ptrdiff_t>
__get_temporary_buffer(ptrdiff_t __len, _Tp*)
{
  if (__len > ptrdiff_t(2147483647 / sizeof(_Tp)))
    __len = 2147483647 / sizeof(_Tp);

  while (__len > 0) {
    _Tp* __tmp = (_Tp*) malloc((size_t)__len * sizeof(_Tp));
    if (__tmp != 0)
      return pair<_Tp*, ptrdiff_t>(__tmp, __len);
    __len /= 2;
  }

  return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
}



template <class _Tp>
inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) {
  return __get_temporary_buffer(__len, (_Tp*) 0);
}
# 67 "/opt/gcc3/include/g++-v3/bits/stl_tempbuf.h" 3
template <class _Tp>
inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len, _Tp*) {
  return __get_temporary_buffer(__len, (_Tp*) 0);
}

template <class _Tp>
void return_temporary_buffer(_Tp* __p) {
  free(__p);
}

template <class _ForwardIterator, class _Tp>
class _Temporary_buffer {
private:
  ptrdiff_t _M_original_len;
  ptrdiff_t _M_len;
  _Tp* _M_buffer;

  void _M_allocate_buffer() {
    _M_original_len = _M_len;
    _M_buffer = 0;

    if (_M_len > (ptrdiff_t)(2147483647 / sizeof(_Tp)))
      _M_len = 2147483647 / sizeof(_Tp);

    while (_M_len > 0) {
      _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
      if (_M_buffer)
        break;
      _M_len /= 2;
    }
  }

  void _M_initialize_buffer(const _Tp&, __true_type) {}
  void _M_initialize_buffer(const _Tp& val, __false_type) {
    uninitialized_fill_n(_M_buffer, _M_len, val);
  }

public:
  ptrdiff_t size() const { return _M_len; }
  ptrdiff_t requested_size() const { return _M_original_len; }
  _Tp* begin() { return _M_buffer; }
  _Tp* end() { return _M_buffer + _M_len; }

  _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {




    typedef typename __type_traits<_Tp>::has_trivial_default_constructor
            _Trivial;


    try {
      _M_len = 0;
      distance(__first, __last, _M_len);
      _M_allocate_buffer();
      if (_M_len > 0)
        _M_initialize_buffer(*__first, _Trivial());
    }
    catch(...) { free(_M_buffer); _M_buffer = 0; _M_len = 0; throw; };
  }

  ~_Temporary_buffer() {
    destroy(_M_buffer, _M_buffer + _M_len);
    free(_M_buffer);
  }

private:

  _Temporary_buffer(const _Temporary_buffer&) {}
  void operator=(const _Temporary_buffer&) {}
};



template <class _ForwardIterator,
          class _Tp

                    = typename iterator_traits<_ForwardIterator>::value_type

         >
struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
{
  temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
    : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}
  ~temporary_buffer() {}
};

}
# 34 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algo.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_algo.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_heap.h" 1 3
# 33 "/opt/gcc3/include/g++-v3/bits/stl_heap.h" 3
namespace std {







template <class _RandomAccessIterator, class _Distance, class _Tp>
void
__push_heap(_RandomAccessIterator __first,
            _Distance __holeIndex, _Distance __topIndex, _Tp __value)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && *(__first + __parent) < __value) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}

template <class _RandomAccessIterator, class _Distance, class _Tp>
inline void
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Distance*, _Tp*)
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
              _Tp(*(__last - 1)));
}

template <class _RandomAccessIterator>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIterator>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIterator>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __push_heap_aux(__first, __last,
                  __distance_type(__first), __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance, class _Tp,
          class _Compare>
void
__push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
            _Distance __topIndex, _Tp __value, _Compare __comp)
{
  _Distance __parent = (__holeIndex - 1) / 2;
  while (__holeIndex > __topIndex && __comp(*(__first + __parent), __value)) {
    *(__first + __holeIndex) = *(__first + __parent);
    __holeIndex = __parent;
    __parent = (__holeIndex - 1) / 2;
  }
  *(__first + __holeIndex) = __value;
}

template <class _RandomAccessIterator, class _Compare,
          class _Distance, class _Tp>
inline void
__push_heap_aux(_RandomAccessIterator __first,
                _RandomAccessIterator __last, _Compare __comp,
                _Distance*, _Tp*)
{
  __push_heap(__first, _Distance((__last - __first) - 1), _Distance(0),
              _Tp(*(__last - 1)), __comp);
}

template <class _RandomAccessIterator, class _Compare>
inline void
push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
          _Compare __comp)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  __push_heap_aux(__first, __last, __comp,
                  __distance_type(__first), __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance, class _Tp>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value);
}

template <class _RandomAccessIterator, class _Tp, class _Distance>
inline void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Distance*)
{
  *__result = *__first;
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first), __value);
}

template <class _RandomAccessIterator, class _Tp>
inline void
__pop_heap_aux(_RandomAccessIterator __first, _RandomAccessIterator __last,
               _Tp*)
{
  __pop_heap(__first, __last - 1, __last - 1,
             _Tp(*(__last - 1)), __distance_type(__first));
}

template <class _RandomAccessIterator>
inline void pop_heap(_RandomAccessIterator __first,
                     _RandomAccessIterator __last)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIterator>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIterator>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __pop_heap_aux(__first, __last, __value_type(__first));
}

template <class _RandomAccessIterator, class _Distance,
          class _Tp, class _Compare>
void
__adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
              _Distance __len, _Tp __value, _Compare __comp)
{
  _Distance __topIndex = __holeIndex;
  _Distance __secondChild = 2 * __holeIndex + 2;
  while (__secondChild < __len) {
    if (__comp(*(__first + __secondChild), *(__first + (__secondChild - 1))))
      __secondChild--;
    *(__first + __holeIndex) = *(__first + __secondChild);
    __holeIndex = __secondChild;
    __secondChild = 2 * (__secondChild + 1);
  }
  if (__secondChild == __len) {
    *(__first + __holeIndex) = *(__first + (__secondChild - 1));
    __holeIndex = __secondChild - 1;
  }
  __push_heap(__first, __holeIndex, __topIndex, __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare,
          class _Distance>
inline void
__pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
           _RandomAccessIterator __result, _Tp __value, _Compare __comp,
           _Distance*)
{
  *__result = *__first;
  __adjust_heap(__first, _Distance(0), _Distance(__last - __first),
                __value, __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Compare>
inline void
__pop_heap_aux(_RandomAccessIterator __first,
               _RandomAccessIterator __last, _Tp*, _Compare __comp)
{
  __pop_heap(__first, __last - 1, __last - 1, _Tp(*(__last - 1)), __comp,
             __distance_type(__first));
}

template <class _RandomAccessIterator, class _Compare>
inline void
pop_heap(_RandomAccessIterator __first,
         _RandomAccessIterator __last, _Compare __comp)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  __pop_heap_aux(__first, __last, __value_type(__first), __comp);
}

template <class _RandomAccessIterator, class _Tp, class _Distance>
void
__make_heap(_RandomAccessIterator __first,
            _RandomAccessIterator __last, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;
  _Distance __len = __last - __first;
  _Distance __parent = (__len - 2)/2;

  while (true) {
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)));
    if (__parent == 0) return;
    __parent--;
  }
}

template <class _RandomAccessIterator>
inline void
make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIterator>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIterator>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __make_heap(__first, __last,
              __value_type(__first), __distance_type(__first));
}

template <class _RandomAccessIterator, class _Compare,
          class _Tp, class _Distance>
void
__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
            _Compare __comp, _Tp*, _Distance*)
{
  if (__last - __first < 2) return;
  _Distance __len = __last - __first;
  _Distance __parent = (__len - 2)/2;

  while (true) {
    __adjust_heap(__first, __parent, __len, _Tp(*(__first + __parent)),
                  __comp);
    if (__parent == 0) return;
    __parent--;
  }
}

template <class _RandomAccessIterator, class _Compare>
inline void
make_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  __make_heap(__first, __last, __comp,
              __value_type(__first), __distance_type(__first));
}

template <class _RandomAccessIterator>
void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIterator>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIterator>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__last - __first > 1)
    pop_heap(__first, __last--);
}

template <class _RandomAccessIterator, class _Compare>
void
sort_heap(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
{
  do { void (*__x)( _RandomAccessIterator ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIterator > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  while (__last - __first > 1)
    pop_heap(__first, __last--, __comp);
}





}
# 35 "/opt/gcc3/include/g++-v3/bits/stl_algo.h" 2 3





namespace std {







template <class _Tp>
inline const _Tp& __median(const _Tp& __a, const _Tp& __b, const _Tp& __c) {
  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);
  if (__a < __b)
    if (__b < __c)
      return __b;
    else if (__a < __c)
      return __c;
    else
      return __a;
  else if (__a < __c)
    return __a;
  else if (__b < __c)
    return __c;
  else
    return __b;
}

template <class _Tp, class _Compare>
inline const _Tp&
__median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp) {
  do { bool (*__x)( _Compare&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  if (__comp(__a, __b))
    if (__comp(__b, __c))
      return __b;
    else if (__comp(__a, __c))
      return __c;
    else
      return __a;
  else if (__comp(__a, __c))
    return __a;
  else if (__comp(__b, __c))
    return __c;
  else
    return __b;
}


template <class _InputIter, class _Function>
_Function for_each(_InputIter __first, _InputIter __last, _Function __f) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __first != __last; ++__first)
    __f(*__first);
  return __f;
}



template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
                       const _Tp& __val,
                       input_iterator_tag)
{
  while (__first != __last && !(*__first == __val))
    ++__first;
  return __first;
}

template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,
                          _Predicate __pred,
                          input_iterator_tag)
{
  while (__first != __last && !__pred(*__first))
    ++__first;
  return __first;
}



template <class _RandomAccessIter, class _Tp>
_RandomAccessIter find(_RandomAccessIter __first, _RandomAccessIter __last,
                       const _Tp& __val,
                       random_access_iterator_tag)
{
  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
    = (__last - __first) >> 2;

  for ( ; __trip_count > 0 ; --__trip_count) {
    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;

    if (*__first == __val) return __first;
    ++__first;
  }

  switch(__last - __first) {
  case 3:
    if (*__first == __val) return __first;
    ++__first;
  case 2:
    if (*__first == __val) return __first;
    ++__first;
  case 1:
    if (*__first == __val) return __first;
    ++__first;
  case 0:
  default:
    return __last;
  }
}

template <class _RandomAccessIter, class _Predicate>
_RandomAccessIter find_if(_RandomAccessIter __first, _RandomAccessIter __last,
                          _Predicate __pred,
                          random_access_iterator_tag)
{
  typename iterator_traits<_RandomAccessIter>::difference_type __trip_count
    = (__last - __first) >> 2;

  for ( ; __trip_count > 0 ; --__trip_count) {
    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;

    if (__pred(*__first)) return __first;
    ++__first;
  }

  switch(__last - __first) {
  case 3:
    if (__pred(*__first)) return __first;
    ++__first;
  case 2:
    if (__pred(*__first)) return __first;
    ++__first;
  case 1:
    if (__pred(*__first)) return __first;
    ++__first;
  case 0:
  default:
    return __last;
  }
}



template <class _InputIter, class _Tp>
inline _InputIter find(_InputIter __first, _InputIter __last,
                       const _Tp& __val)
{
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_InputIter>::value_type&, _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_InputIter>::value_type&, const _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);

  return find(__first, __last, __val, __iterator_category(__first));
}

template <class _InputIter, class _Predicate>
inline _InputIter find_if(_InputIter __first, _InputIter __last,
                          _Predicate __pred) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_InputIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  return find_if(__first, __last, __pred, __iterator_category(__first));
}



template <class _ForwardIter>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last)
    return __last;
  _ForwardIter __next = __first;
  while(++__next != __last) {
    if (*__first == *__next)
      return __first;
    __first = __next;
  }
  return __last;
}

template <class _ForwardIter, class _BinaryPredicate>
_ForwardIter adjacent_find(_ForwardIter __first, _ForwardIter __last,
                           _BinaryPredicate __binary_pred) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPredicate&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last)
    return __last;
  _ForwardIter __next = __first;
  while(++__next != __last) {
    if (__binary_pred(*__first, *__next))
      return __first;
    __first = __next;
  }
  return __last;
}







template <class _InputIter, class _Tp, class _Size>
void count(_InputIter __first, _InputIter __last, const _Tp& __value,
           _Size& __n) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _EqualityComparable_concept_specification< _Tp > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);
  for ( ; __first != __last; ++__first)
    if (*__first == __value)
      ++__n;
}

template <class _InputIter, class _Predicate, class _Size>
void count_if(_InputIter __first, _InputIter __last, _Predicate __pred,
              _Size& __n) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_InputIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      ++__n;
}



template <class _InputIter, class _Tp>
typename iterator_traits<_InputIter>::difference_type
count(_InputIter __first, _InputIter __last, const _Tp& __value) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _EqualityComparable_concept_specification< _Tp > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);
  typename iterator_traits<_InputIter>::difference_type __n = 0;
  for ( ; __first != __last; ++__first)
    if (*__first == __value)
      ++__n;
  return __n;
}

template <class _InputIter, class _Predicate>
typename iterator_traits<_InputIter>::difference_type
count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_InputIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  typename iterator_traits<_InputIter>::difference_type __n = 0;
  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      ++__n;
  return __n;
}






template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
                     _ForwardIter2 __first2, _ForwardIter2 __last2)
{
  do { void (*__x)( _ForwardIter1 ) = _ForwardIterator_concept_specification< _ForwardIter1 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _ForwardIterator_concept_specification< _ForwardIter2 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_ForwardIter1>::value_type&, typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_ForwardIter1>::value_type&, const typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);




  if (__first1 == __last1 || __first2 == __last2)
    return __first1;


  _ForwardIter2 __tmp(__first2);
  ++__tmp;
  if (__tmp == __last2)
    return find(__first1, __last1, *__first2);



  _ForwardIter2 __p1, __p;

  __p1 = __first2; ++__p1;

  _ForwardIter1 __current = __first1;

  while (__first1 != __last1) {
    __first1 = find(__first1, __last1, *__first2);
    if (__first1 == __last1)
      return __last1;

    __p = __p1;
    __current = __first1;
    if (++__current == __last1)
      return __last1;

    while (*__current == *__p) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }

    ++__first1;
  }
  return __first1;
}

template <class _ForwardIter1, class _ForwardIter2, class _BinaryPred>
_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,
                     _ForwardIter2 __first2, _ForwardIter2 __last2,
                     _BinaryPred __predicate)
{
  do { void (*__x)( _ForwardIter1 ) = _ForwardIterator_concept_specification< _ForwardIter1 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _ForwardIterator_concept_specification< _ForwardIter2 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPred&, const typename iterator_traits<_ForwardIter1>::value_type&, const typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPred, bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);




  if (__first1 == __last1 || __first2 == __last2)
    return __first1;


  _ForwardIter2 __tmp(__first2);
  ++__tmp;
  if (__tmp == __last2) {
    while (__first1 != __last1 && !__predicate(*__first1, *__first2))
      ++__first1;
    return __first1;
  }



  _ForwardIter2 __p1, __p;

  __p1 = __first2; ++__p1;

  _ForwardIter1 __current = __first1;

  while (__first1 != __last1) {
    while (__first1 != __last1) {
      if (__predicate(*__first1, *__first2))
        break;
      ++__first1;
    }
    while (__first1 != __last1 && !__predicate(*__first1, *__first2))
      ++__first1;
    if (__first1 == __last1)
      return __last1;

    __p = __p1;
    __current = __first1;
    if (++__current == __last1) return __last1;

    while (__predicate(*__current, *__p)) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }

    ++__first1;
  }
  return __first1;
}



template <class _ForwardIter, class _Integer, class _Tp>
_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
                      _Integer __count, const _Tp& __val) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _EqualityComparable_concept_specification< _Tp > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  if (__count <= 0)
    return __first;
  else {
    __first = find(__first, __last, __val);
    while (__first != __last) {
      _Integer __n = __count - 1;
      _ForwardIter __i = __first;
      ++__i;
      while (__i != __last && __n != 0 && *__i == __val) {
        ++__i;
        --__n;
      }
      if (__n == 0)
        return __first;
      else
        __first = find(__i, __last, __val);
    }
    return __last;
  }
}

template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>
_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,
                      _Integer __count, const _Tp& __val,
                      _BinaryPred __binary_pred) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPred&, const typename iterator_traits<_ForwardIter>::value_type&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPred, bool, typename iterator_traits<_ForwardIter>::value_type, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);

  if (__count <= 0)
    return __first;
  else {
    while (__first != __last) {
      if (__binary_pred(*__first, __val))
        break;
      ++__first;
    }
    while (__first != __last) {
      _Integer __n = __count - 1;
      _ForwardIter __i = __first;
      ++__i;
      while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {
        ++__i;
        --__n;
      }
      if (__n == 0)
        return __first;
      else {
        while (__i != __last) {
          if (__binary_pred(*__i, __val))
            break;
          ++__i;
        }
        __first = __i;
      }
    }
    return __last;
  }
}



template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,
                          _ForwardIter2 __first2) {
  do { void (*__x)( _ForwardIter1 ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter1 > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter2 > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter1>::value_type , typename iterator_traits<_ForwardIter2>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_ForwardIter1>::value_type , typename iterator_traits<_ForwardIter2>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_ForwardIter2>::value_type , typename iterator_traits<_ForwardIter1>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_ForwardIter2>::value_type , typename iterator_traits<_ForwardIter1>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  for ( ; __first1 != __last1; ++__first1, ++__first2)
    iter_swap(__first1, __first2);
  return __first2;
}



template <class _InputIter, class _OutputIter, class _UnaryOperation>
_OutputIter transform(_InputIter __first, _InputIter __last,
                      _OutputIter __result, _UnaryOperation __unary_op) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first, ++__result)
    *__result = __unary_op(*__first);
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _BinaryOperation>
_OutputIter transform(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _OutputIter __result,
                      _BinaryOperation __binary_op) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
    *__result = __binary_op(*__first1, *__first2);
  return __result;
}



template <class _ForwardIter, class _Tp>
void replace(_ForwardIter __first, _ForwardIter __last,
             const _Tp& __old_value, const _Tp& __new_value) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_ForwardIter>::value_type&, _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter>::value_type, _Tp>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_ForwardIter>::value_type&, const _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter>::value_type, _Tp>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);

  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_CONVERT_ERROR< _Tp , typename iterator_traits<_ForwardIter>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);
  for ( ; __first != __last; ++__first)
    if (*__first == __old_value)
      *__first = __new_value;
}

template <class _ForwardIter, class _Predicate, class _Tp>
void replace_if(_ForwardIter __first, _ForwardIter __last,
                _Predicate __pred, const _Tp& __new_value) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_CONVERT_ERROR< _Tp , typename iterator_traits<_ForwardIter>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_ForwardIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first)
    if (__pred(*__first))
      *__first = __new_value;
}

template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter replace_copy(_InputIter __first, _InputIter __last,
                         _OutputIter __result,
                         const _Tp& __old_value, const _Tp& __new_value) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_InputIter>::value_type&, _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_InputIter>::value_type&, const _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);

  for ( ; __first != __last; ++__first, ++__result)
    *__result = *__first == __old_value ? __new_value : *__first;
  return __result;
}

template <class _InputIter, class _OutputIter, class _Predicate, class _Tp>
_OutputIter replace_copy_if(_InputIter __first, _InputIter __last,
                            _OutputIter __result,
                            _Predicate __pred, const _Tp& __new_value) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_InputIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first, ++__result)
    *__result = __pred(*__first) ? __new_value : *__first;
  return __result;
}



template <class _ForwardIter, class _Generator>
void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { typename iterator_traits<_ForwardIter>::value_type (*__x)( _Generator&) = _STL_GENERATOR_ERROR< _Generator, typename iterator_traits<_ForwardIter>::value_type>::__generator_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first)
    *__first = __gen();
}

template <class _OutputIter, class _Size, class _Generator>
_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) {
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  for ( ; __n > 0; --__n, ++__first)
    *__first = __gen();
  return __first;
}



template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter remove_copy(_InputIter __first, _InputIter __last,
                        _OutputIter __result, const _Tp& __value) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_InputIter>::value_type&, _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_InputIter>::value_type&, const _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, _Tp>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);

  for ( ; __first != __last; ++__first)
    if (!(*__first == __value)) {
      *__result = *__first;
      ++__result;
    }
  return __result;
}

template <class _InputIter, class _OutputIter, class _Predicate>
_OutputIter remove_copy_if(_InputIter __first, _InputIter __last,
                           _OutputIter __result, _Predicate __pred) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_InputIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  for ( ; __first != __last; ++__first)
    if (!__pred(*__first)) {
      *__result = *__first;
      ++__result;
    }
  return __result;
}

template <class _ForwardIter, class _Tp>
_ForwardIter remove(_ForwardIter __first, _ForwardIter __last,
                    const _Tp& __value) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_ForwardIter>::value_type&, _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter>::value_type, _Tp>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_ForwardIter>::value_type&, const _Tp& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter>::value_type, _Tp>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);

  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_CONVERT_ERROR< _Tp , typename iterator_traits<_ForwardIter>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);
  __first = find(__first, __last, __value);
  _ForwardIter __i = __first;
  return __first == __last ? __first
                           : remove_copy(++__i, __last, __first, __value);
}

template <class _ForwardIter, class _Predicate>
_ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last,
                       _Predicate __pred) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_ForwardIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  __first = find_if(__first, __last, __pred);
  _ForwardIter __i = __first;
  return __first == __last ? __first
                           : remove_copy_if(++__i, __last, __first, __pred);
}



template <class _InputIter, class _OutputIter, class _Tp>
_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result, _Tp*) {
  _Tp __value = *__first;
  *__result = __value;
  while (++__first != __last)
    if (!(__value == *__first)) {
      __value = *__first;
      *++__result = __value;
    }
  return ++__result;
}

template <class _InputIter, class _OutputIter>
inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                                 _OutputIter __result,
                                 output_iterator_tag) {
  return __unique_copy(__first, __last, __result, __value_type(__first));
}

template <class _InputIter, class _ForwardIter>
_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
                           _ForwardIter __result, forward_iterator_tag) {
  *__result = *__first;
  while (++__first != __last)
    if (!(*__result == *__first))
      *++__result = *__first;
  return ++__result;
}

template <class _InputIter, class _OutputIter>
inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
                               _OutputIter __result) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_InputIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last) return __result;
  return __unique_copy(__first, __last, __result,
                       __iterator_category(__result));
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate,
          class _Tp>
_OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                          _OutputIter __result,
                          _BinaryPredicate __binary_pred, _Tp*) {
  do { bool (*__x)( _BinaryPredicate&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  _Tp __value = *__first;
  *__result = __value;
  while (++__first != __last)
    if (!__binary_pred(__value, *__first)) {
      __value = *__first;
      *++__result = __value;
    }
  return ++__result;
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,
                                 _OutputIter __result,
                                 _BinaryPredicate __binary_pred,
                                 output_iterator_tag) {
  return __unique_copy(__first, __last, __result, __binary_pred,
                       __value_type(__first));
}

template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,
                           _ForwardIter __result,
                           _BinaryPredicate __binary_pred,
                           forward_iterator_tag) {
  do { bool (*__x)( _BinaryPredicate&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_InputIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_InputIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  *__result = *__first;
  while (++__first != __last)
    if (!__binary_pred(*__result, *__first)) *++__result = *__first;
  return ++__result;
}

template <class _InputIter, class _OutputIter, class _BinaryPredicate>
inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,
                               _OutputIter __result,
                               _BinaryPredicate __binary_pred) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  if (__first == __last) return __result;
  return __unique_copy(__first, __last, __result, __binary_pred,
                       __iterator_category(__result));
}

template <class _ForwardIter>
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _EqualityComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_EqualityComparable_requirement_violation; __x = __x; } while (0);

  __first = adjacent_find(__first, __last);
  return unique_copy(__first, __last, __first);
}

template <class _ForwardIter, class _BinaryPredicate>
_ForwardIter unique(_ForwardIter __first, _ForwardIter __last,
                    _BinaryPredicate __binary_pred) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPredicate&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  __first = adjacent_find(__first, __last, __binary_pred);
  return unique_copy(__first, __last, __first, __binary_pred);
}



template <class _BidirectionalIter>
void __reverse(_BidirectionalIter __first, _BidirectionalIter __last,
               bidirectional_iterator_tag) {
  while (true)
    if (__first == __last || __first == --__last)
      return;
    else
      iter_swap(__first++, __last);
}

template <class _RandomAccessIter>
void __reverse(_RandomAccessIter __first, _RandomAccessIter __last,
               random_access_iterator_tag) {
  while (__first < __last)
    iter_swap(__first++, --__last);
}

template <class _BidirectionalIter>
inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last) {
  do { void (*__x)( _BidirectionalIter ) = _Mutable_BidirectionalIterator_concept_specification< _BidirectionalIter > ::_Mutable_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  __reverse(__first, __last, __iterator_category(__first));
}

template <class _BidirectionalIter, class _OutputIter>
_OutputIter reverse_copy(_BidirectionalIter __first,
                         _BidirectionalIter __last,
                         _OutputIter __result) {
  do { void (*__x)( _BidirectionalIter ) = _BidirectionalIterator_concept_specification< _BidirectionalIter > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  while (__first != __last) {
    --__last;
    *__result = *__last;
    ++__result;
  }
  return __result;
}



template <class _EuclideanRingElement>
_EuclideanRingElement __gcd(_EuclideanRingElement __m,
                            _EuclideanRingElement __n)
{
  while (__n != 0) {
    _EuclideanRingElement __t = __m % __n;
    __m = __n;
    __n = __t;
  }
  return __m;
}

template <class _ForwardIter, class _Distance>
_ForwardIter __rotate(_ForwardIter __first,
                      _ForwardIter __middle,
                      _ForwardIter __last,
                      _Distance*,
                      forward_iterator_tag) {
  if (__first == __middle)
    return __last;
  if (__last == __middle)
    return __first;

  _ForwardIter __first2 = __middle;
  do {
    swap(*__first++, *__first2++);
    if (__first == __middle)
      __middle = __first2;
  } while (__first2 != __last);

  _ForwardIter __new_middle = __first;

  __first2 = __middle;

  while (__first2 != __last) {
    swap (*__first++, *__first2++);
    if (__first == __middle)
      __middle = __first2;
    else if (__first2 == __last)
      __first2 = __middle;
  }

  return __new_middle;
}


template <class _BidirectionalIter, class _Distance>
_BidirectionalIter __rotate(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance*,
                            bidirectional_iterator_tag) {
  do { void (*__x)( _BidirectionalIter ) = _Mutable_BidirectionalIterator_concept_specification< _BidirectionalIter > ::_Mutable_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  if (__first == __middle)
    return __last;
  if (__last == __middle)
    return __first;

  __reverse(__first, __middle, bidirectional_iterator_tag());
  __reverse(__middle, __last, bidirectional_iterator_tag());

  while (__first != __middle && __middle != __last)
    swap (*__first++, *--__last);

  if (__first == __middle) {
    __reverse(__middle, __last, bidirectional_iterator_tag());
    return __last;
  }
  else {
    __reverse(__first, __middle, bidirectional_iterator_tag());
    return __first;
  }
}

template <class _RandomAccessIter, class _Distance, class _Tp>
_RandomAccessIter __rotate(_RandomAccessIter __first,
                           _RandomAccessIter __middle,
                           _RandomAccessIter __last,
                           _Distance *, _Tp *) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  _Distance __n = __last - __first;
  _Distance __k = __middle - __first;
  _Distance __l = __n - __k;
  _RandomAccessIter __result = __first + (__last - __middle);

  if (__k == 0)
    return __last;

  else if (__k == __l) {
    swap_ranges(__first, __middle, __middle);
    return __result;
  }

  _Distance __d = __gcd(__n, __k);

  for (_Distance __i = 0; __i < __d; __i++) {
    _Tp __tmp = *__first;
    _RandomAccessIter __p = __first;

    if (__k < __l) {
      for (_Distance __j = 0; __j < __l/__d; __j++) {
        if (__p > __first + __l) {
          *__p = *(__p - __l);
          __p -= __l;
        }

        *__p = *(__p + __k);
        __p += __k;
      }
    }

    else {
      for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {
        if (__p < __last - __k) {
          *__p = *(__p + __k);
          __p += __k;
        }

        *__p = * (__p - __l);
        __p -= __l;
      }
    }

    *__p = __tmp;
    ++__first;
  }

  return __result;
}

template <class _ForwardIter>
inline _ForwardIter rotate(_ForwardIter __first, _ForwardIter __middle,
                           _ForwardIter __last) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  return __rotate(__first, __middle, __last,
                  __distance_type(__first),
                  __iterator_category(__first));
}

template <class _ForwardIter, class _OutputIter>
_OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,
                        _ForwardIter __last, _OutputIter __result) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  return copy(__first, __middle, copy(__middle, __last, __result));
}





template <class _Distance>
inline _Distance __random_number(_Distance __n) {



  return lrand48() % __n;

}



template <class _RandomAccessIter>
inline void random_shuffle(_RandomAccessIter __first,
                           _RandomAccessIter __last) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __random_number((__i - __first) + 1));
}

template <class _RandomAccessIter, class _RandomNumberGenerator>
void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,
                    _RandomNumberGenerator& __rand) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    iter_swap(__i, __first + __rand((__i - __first) + 1));
}



template <class _ForwardIter, class _OutputIter, class _Distance>
_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
                            _OutputIter __out, const _Distance __n)
{
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  _Distance __remaining = 0;
  distance(__first, __last, __remaining);
  _Distance __m = min(__n, __remaining);

  while (__m > 0) {
    if (__random_number(__remaining) < __m) {
      *__out = *__first;
      ++__out;
      --__m;
    }

    --__remaining;
    ++__first;
  }
  return __out;
}

template <class _ForwardIter, class _OutputIter, class _Distance,
          class _RandomNumberGenerator>
_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,
                            _OutputIter __out, const _Distance __n,
                            _RandomNumberGenerator& __rand)
{
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { _Distance (*__x)( _RandomNumberGenerator&, const _Distance& ) = _STL_UNARY_FUNCTION_ERROR< _RandomNumberGenerator, _Distance, _Distance>::__unary_function_requirement_violation; __x = __x; } while (0);
  _Distance __remaining = 0;
  distance(__first, __last, __remaining);
  _Distance __m = min(__n, __remaining);

  while (__m > 0) {
    if (__rand(__remaining) < __m) {
      *__out = *__first;
      ++__out;
      --__m;
    }

    --__remaining;
    ++__first;
  }
  return __out;
}

template <class _InputIter, class _RandomAccessIter, class _Distance>
_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
                                  _RandomAccessIter __out,
                                  const _Distance __n)
{
  _Distance __m = 0;
  _Distance __t = __n;
  for ( ; __first != __last && __m < __n; ++__m, ++__first)
    __out[__m] = *__first;

  while (__first != __last) {
    ++__t;
    _Distance __M = __random_number(__t);
    if (__M < __n)
      __out[__M] = *__first;
    ++__first;
  }

  return __out + __m;
}

template <class _InputIter, class _RandomAccessIter,
          class _RandomNumberGenerator, class _Distance>
_RandomAccessIter __random_sample(_InputIter __first, _InputIter __last,
                                  _RandomAccessIter __out,
                                  _RandomNumberGenerator& __rand,
                                  const _Distance __n)
{
  do { _Distance (*__x)( _RandomNumberGenerator&, const _Distance& ) = _STL_UNARY_FUNCTION_ERROR< _RandomNumberGenerator, _Distance, _Distance>::__unary_function_requirement_violation; __x = __x; } while (0);
  _Distance __m = 0;
  _Distance __t = __n;
  for ( ; __first != __last && __m < __n; ++__m, ++__first)
    __out[__m] = *__first;

  while (__first != __last) {
    ++__t;
    _Distance __M = __rand(__t);
    if (__M < __n)
      __out[__M] = *__first;
    ++__first;
  }

  return __out + __m;
}

template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
random_sample(_InputIter __first, _InputIter __last,
              _RandomAccessIter __out_first, _RandomAccessIter __out_last)
{
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  return __random_sample(__first, __last,
                         __out_first, __out_last - __out_first);
}


template <class _InputIter, class _RandomAccessIter,
          class _RandomNumberGenerator>
inline _RandomAccessIter
random_sample(_InputIter __first, _InputIter __last,
              _RandomAccessIter __out_first, _RandomAccessIter __out_last,
              _RandomNumberGenerator& __rand)
{
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  return __random_sample(__first, __last,
                         __out_first, __rand,
                         __out_last - __out_first);
}



template <class _ForwardIter, class _Predicate>
_ForwardIter __partition(_ForwardIter __first,
                         _ForwardIter __last,
                         _Predicate __pred,
                         forward_iterator_tag) {
  if (__first == __last) return __first;

  while (__pred(*__first))
    if (++__first == __last) return __first;

  _ForwardIter __next = __first;

  while (++__next != __last)
    if (__pred(*__next)) {
      swap(*__first, *__next);
      ++__first;
    }

  return __first;
}

template <class _BidirectionalIter, class _Predicate>
_BidirectionalIter __partition(_BidirectionalIter __first,
                               _BidirectionalIter __last,
                               _Predicate __pred,
                               bidirectional_iterator_tag) {
  while (true) {
    while (true)
      if (__first == __last)
        return __first;
      else if (__pred(*__first))
        ++__first;
      else
        break;
    --__last;
    while (true)
      if (__first == __last)
        return __first;
      else if (!__pred(*__last))
        --__last;
      else
        break;
    iter_swap(__first, __last);
    ++__first;
  }
}

template <class _ForwardIter, class _Predicate>
inline _ForwardIter partition(_ForwardIter __first,
                              _ForwardIter __last,
                              _Predicate __pred) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_ForwardIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  return __partition(__first, __last, __pred, __iterator_category(__first));
}


template <class _ForwardIter, class _Predicate, class _Distance>
_ForwardIter __inplace_stable_partition(_ForwardIter __first,
                                        _ForwardIter __last,
                                        _Predicate __pred, _Distance __len) {
  if (__len == 1)
    return __pred(*__first) ? __last : __first;
  _ForwardIter __middle = __first;
  advance(__middle, __len / 2);
  return rotate(__inplace_stable_partition(__first, __middle, __pred,
                                           __len / 2),
                __middle,
                __inplace_stable_partition(__middle, __last, __pred,
                                           __len - __len / 2));
}

template <class _ForwardIter, class _Pointer, class _Predicate,
          class _Distance>
_ForwardIter __stable_partition_adaptive(_ForwardIter __first,
                                         _ForwardIter __last,
                                         _Predicate __pred, _Distance __len,
                                         _Pointer __buffer,
                                         _Distance __buffer_size)
{
  if (__len <= __buffer_size) {
    _ForwardIter __result1 = __first;
    _Pointer __result2 = __buffer;
    for ( ; __first != __last ; ++__first)
      if (__pred(*__first)) {
        *__result1 = *__first;
        ++__result1;
      }
      else {
        *__result2 = *__first;
        ++__result2;
      }
    copy(__buffer, __result2, __result1);
    return __result1;
  }
  else {
    _ForwardIter __middle = __first;
    advance(__middle, __len / 2);
    return rotate(__stable_partition_adaptive(
                          __first, __middle, __pred,
                          __len / 2, __buffer, __buffer_size),
                    __middle,
                    __stable_partition_adaptive(
                          __middle, __last, __pred,
                          __len - __len / 2, __buffer, __buffer_size));
  }
}

template <class _ForwardIter, class _Predicate, class _Tp, class _Distance>
inline _ForwardIter
__stable_partition_aux(_ForwardIter __first, _ForwardIter __last,
                       _Predicate __pred, _Tp*, _Distance*)
{
  _Temporary_buffer<_ForwardIter, _Tp> __buf(__first, __last);
  if (__buf.size() > 0)
    return __stable_partition_adaptive(__first, __last, __pred,
                                       _Distance(__buf.requested_size()),
                                       __buf.begin(), __buf.size());
  else
    return __inplace_stable_partition(__first, __last, __pred,
                                      _Distance(__buf.requested_size()));
}

template <class _ForwardIter, class _Predicate>
inline _ForwardIter stable_partition(_ForwardIter __first,
                                     _ForwardIter __last,
                                     _Predicate __pred) {
  do { void (*__x)( _ForwardIter ) = _Mutable_ForwardIterator_concept_specification< _ForwardIter > ::_Mutable_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Predicate&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_UNARY_FUNCTION_ERROR< _Predicate, bool, typename iterator_traits<_ForwardIter>::value_type>::__unary_function_requirement_violation; __x = __x; } while (0);

  if (__first == __last)
    return __first;
  else
    return __stable_partition_aux(__first, __last, __pred,
                                  __value_type(__first),
                                  __distance_type(__first));
}

template <class _RandomAccessIter, class _Tp>
_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
                                        _RandomAccessIter __last,
                                        _Tp __pivot)
{
  while (true) {
    while (*__first < __pivot)
      ++__first;
    --__last;
    while (__pivot < *__last)
      --__last;
    if (!(__first < __last))
      return __first;
    iter_swap(__first, __last);
    ++__first;
  }
}

template <class _RandomAccessIter, class _Tp, class _Compare>
_RandomAccessIter __unguarded_partition(_RandomAccessIter __first,
                                        _RandomAccessIter __last,
                                        _Tp __pivot, _Compare __comp)
{
  while (true) {
    while (__comp(*__first, __pivot))
      ++__first;
    --__last;
    while (__comp(__pivot, *__last))
      --__last;
    if (!(__first < __last))
      return __first;
    iter_swap(__first, __last);
    ++__first;
  }
}

const int __stl_threshold = 16;



template <class _RandomAccessIter, class _Tp>
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val) {
  _RandomAccessIter __next = __last;
  --__next;
  while (__val < *__next) {
    *__last = *__next;
    __last = __next;
    --__next;
  }
  *__last = __val;
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __unguarded_linear_insert(_RandomAccessIter __last, _Tp __val,
                               _Compare __comp) {
  _RandomAccessIter __next = __last;
  --__next;
  while (__comp(__val, *__next)) {
    *__last = *__next;
    __last = __next;
    --__next;
  }
  *__last = __val;
}

template <class _RandomAccessIter, class _Tp>
inline void __linear_insert(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Tp*) {
  _Tp __val = *__last;
  if (__val < *__first) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }
  else
    __unguarded_linear_insert(__last, __val);
}

template <class _RandomAccessIter, class _Tp, class _Compare>
inline void __linear_insert(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Tp*, _Compare __comp) {
  _Tp __val = *__last;
  if (__comp(__val, *__first)) {
    copy_backward(__first, __last, __last + 1);
    *__first = __val;
  }
  else
    __unguarded_linear_insert(__last, __val, __comp);
}

template <class _RandomAccessIter>
void __insertion_sort(_RandomAccessIter __first, _RandomAccessIter __last) {
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first));
}

template <class _RandomAccessIter, class _Compare>
void __insertion_sort(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Compare __comp) {
  if (__first == __last) return;
  for (_RandomAccessIter __i = __first + 1; __i != __last; ++__i)
    __linear_insert(__first, __i, __value_type(__first), __comp);
}

template <class _RandomAccessIter, class _Tp>
void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
                                    _RandomAccessIter __last, _Tp*) {
  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _Tp(*__i));
}

template <class _RandomAccessIter>
inline void __unguarded_insertion_sort(_RandomAccessIter __first,
                                _RandomAccessIter __last) {
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __unguarded_insertion_sort_aux(_RandomAccessIter __first,
                                    _RandomAccessIter __last,
                                    _Tp*, _Compare __comp) {
  for (_RandomAccessIter __i = __first; __i != __last; ++__i)
    __unguarded_linear_insert(__i, _Tp(*__i), __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void __unguarded_insertion_sort(_RandomAccessIter __first,
                                       _RandomAccessIter __last,
                                       _Compare __comp) {
  __unguarded_insertion_sort_aux(__first, __last, __value_type(__first),
                                 __comp);
}

template <class _RandomAccessIter>
void __final_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last) {
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold);
    __unguarded_insertion_sort(__first + __stl_threshold, __last);
  }
  else
    __insertion_sort(__first, __last);
}

template <class _RandomAccessIter, class _Compare>
void __final_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Compare __comp) {
  if (__last - __first > __stl_threshold) {
    __insertion_sort(__first, __first + __stl_threshold, __comp);
    __unguarded_insertion_sort(__first + __stl_threshold, __last, __comp);
  }
  else
    __insertion_sort(__first, __last, __comp);
}

template <class _Size>
inline _Size __lg(_Size __n) {
  _Size __k;
  for (__k = 0; __n != 1; __n >>= 1) ++__k;
  return __k;
}

template <class _RandomAccessIter, class _Tp, class _Size>
void __introsort_loop(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Tp*,
                      _Size __depth_limit)
{
  while (__last - __first > __stl_threshold) {
    if (__depth_limit == 0) {
      partial_sort(__first, __last, __last);
      return;
    }
    --__depth_limit;
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1))));
    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit);
    __last = __cut;
  }
}

template <class _RandomAccessIter, class _Tp, class _Size, class _Compare>
void __introsort_loop(_RandomAccessIter __first,
                      _RandomAccessIter __last, _Tp*,
                      _Size __depth_limit, _Compare __comp)
{
  while (__last - __first > __stl_threshold) {
    if (__depth_limit == 0) {
      partial_sort(__first, __last, __last, __comp);
      return;
    }
    --__depth_limit;
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1), __comp)),
       __comp);
    __introsort_loop(__cut, __last, (_Tp*) 0, __depth_limit, __comp);
    __last = __cut;
  }
}

template <class _RandomAccessIter>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first != __last) {
    __introsort_loop(__first, __last,
                     __value_type(__first),
                     __lg(__last - __first) * 2);
    __final_insertion_sort(__first, __last);
  }
}

template <class _RandomAccessIter, class _Compare>
inline void sort(_RandomAccessIter __first, _RandomAccessIter __last,
                 _Compare __comp) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first != __last) {
    __introsort_loop(__first, __last,
                     __value_type(__first),
                     __lg(__last - __first) * 2,
                     __comp);
    __final_insertion_sort(__first, __last, __comp);
  }
}



template <class _RandomAccessIter>
void __inplace_stable_sort(_RandomAccessIter __first,
                           _RandomAccessIter __last) {
  if (__last - __first < 15) {
    __insertion_sort(__first, __last);
    return;
  }
  _RandomAccessIter __middle = __first + (__last - __first) / 2;
  __inplace_stable_sort(__first, __middle);
  __inplace_stable_sort(__middle, __last);
  __merge_without_buffer(__first, __middle, __last,
                         __middle - __first,
                         __last - __middle);
}

template <class _RandomAccessIter, class _Compare>
void __inplace_stable_sort(_RandomAccessIter __first,
                           _RandomAccessIter __last, _Compare __comp) {
  if (__last - __first < 15) {
    __insertion_sort(__first, __last, __comp);
    return;
  }
  _RandomAccessIter __middle = __first + (__last - __first) / 2;
  __inplace_stable_sort(__first, __middle, __comp);
  __inplace_stable_sort(__middle, __last, __comp);
  __merge_without_buffer(__first, __middle, __last,
                         __middle - __first,
                         __last - __middle,
                         __comp);
}

template <class _RandomAccessIter1, class _RandomAccessIter2,
          class _Distance>
void __merge_sort_loop(_RandomAccessIter1 __first,
                       _RandomAccessIter1 __last,
                       _RandomAccessIter2 __result, _Distance __step_size) {
  _Distance __two_step = 2 * __step_size;

  while (__last - __first >= __two_step) {
    __result = merge(__first, __first + __step_size,
                     __first + __step_size, __first + __two_step,
                     __result);
    __first += __two_step;
  }

  __step_size = min(_Distance(__last - __first), __step_size);
  merge(__first, __first + __step_size, __first + __step_size, __last,
        __result);
}

template <class _RandomAccessIter1, class _RandomAccessIter2,
          class _Distance, class _Compare>
void __merge_sort_loop(_RandomAccessIter1 __first,
                       _RandomAccessIter1 __last,
                       _RandomAccessIter2 __result, _Distance __step_size,
                       _Compare __comp) {
  _Distance __two_step = 2 * __step_size;

  while (__last - __first >= __two_step) {
    __result = merge(__first, __first + __step_size,
                     __first + __step_size, __first + __two_step,
                     __result,
                     __comp);
    __first += __two_step;
  }
  __step_size = min(_Distance(__last - __first), __step_size);

  merge(__first, __first + __step_size,
        __first + __step_size, __last,
        __result,
        __comp);
}

const int __stl_chunk_size = 7;

template <class _RandomAccessIter, class _Distance>
void __chunk_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Distance __chunk_size)
{
  while (__last - __first >= __chunk_size) {
    __insertion_sort(__first, __first + __chunk_size);
    __first += __chunk_size;
  }
  __insertion_sort(__first, __last);
}

template <class _RandomAccessIter, class _Distance, class _Compare>
void __chunk_insertion_sort(_RandomAccessIter __first,
                            _RandomAccessIter __last,
                            _Distance __chunk_size, _Compare __comp)
{
  while (__last - __first >= __chunk_size) {
    __insertion_sort(__first, __first + __chunk_size, __comp);
    __first += __chunk_size;
  }
  __insertion_sort(__first, __last, __comp);
}

template <class _RandomAccessIter, class _Pointer, class _Distance>
void __merge_sort_with_buffer(_RandomAccessIter __first,
                              _RandomAccessIter __last,
                              _Pointer __buffer, _Distance*) {
  _Distance __len = __last - __first;
  _Pointer __buffer_last = __buffer + __len;

  _Distance __step_size = __stl_chunk_size;
  __chunk_insertion_sort(__first, __last, __step_size);

  while (__step_size < __len) {
    __merge_sort_loop(__first, __last, __buffer, __step_size);
    __step_size *= 2;
    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
    __step_size *= 2;
  }
}

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _Compare>
void __merge_sort_with_buffer(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Pointer __buffer,
                              _Distance*, _Compare __comp) {
  _Distance __len = __last - __first;
  _Pointer __buffer_last = __buffer + __len;

  _Distance __step_size = __stl_chunk_size;
  __chunk_insertion_sort(__first, __last, __step_size, __comp);

  while (__step_size < __len) {
    __merge_sort_loop(__first, __last, __buffer, __step_size, __comp);
    __step_size *= 2;
    __merge_sort_loop(__buffer, __buffer_last, __first, __step_size, __comp);
    __step_size *= 2;
  }
}

template <class _RandomAccessIter, class _Pointer, class _Distance>
void __stable_sort_adaptive(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Pointer __buffer,
                            _Distance __buffer_size) {
  _Distance __len = (__last - __first + 1) / 2;
  _RandomAccessIter __middle = __first + __len;
  if (__len > __buffer_size) {
    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size);
    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size);
  }
  else {
    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0);
    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0);
  }
  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                   _Distance(__last - __middle), __buffer, __buffer_size);
}

template <class _RandomAccessIter, class _Pointer, class _Distance,
          class _Compare>
void __stable_sort_adaptive(_RandomAccessIter __first,
                            _RandomAccessIter __last, _Pointer __buffer,
                            _Distance __buffer_size, _Compare __comp) {
  _Distance __len = (__last - __first + 1) / 2;
  _RandomAccessIter __middle = __first + __len;
  if (__len > __buffer_size) {
    __stable_sort_adaptive(__first, __middle, __buffer, __buffer_size,
                           __comp);
    __stable_sort_adaptive(__middle, __last, __buffer, __buffer_size,
                           __comp);
  }
  else {
    __merge_sort_with_buffer(__first, __middle, __buffer, (_Distance*)0,
                               __comp);
    __merge_sort_with_buffer(__middle, __last, __buffer, (_Distance*)0,
                               __comp);
  }
  __merge_adaptive(__first, __middle, __last, _Distance(__middle - __first),
                   _Distance(__last - __middle), __buffer, __buffer_size,
                   __comp);
}

template <class _RandomAccessIter, class _Tp, class _Distance>
inline void __stable_sort_aux(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Tp*, _Distance*) {
  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
  if (buf.begin() == 0)
    __inplace_stable_sort(__first, __last);
  else
    __stable_sort_adaptive(__first, __last, buf.begin(),
                           _Distance(buf.size()));
}

template <class _RandomAccessIter, class _Tp, class _Distance, class _Compare>
inline void __stable_sort_aux(_RandomAccessIter __first,
                              _RandomAccessIter __last, _Tp*, _Distance*,
                              _Compare __comp) {
  _Temporary_buffer<_RandomAccessIter, _Tp> buf(__first, __last);
  if (buf.begin() == 0)
    __inplace_stable_sort(__first, __last, __comp);
  else
    __stable_sort_adaptive(__first, __last, buf.begin(),
                           _Distance(buf.size()),
                           __comp);
}

template <class _RandomAccessIter>
inline void stable_sort(_RandomAccessIter __first,
                        _RandomAccessIter __last) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __stable_sort_aux(__first, __last,
                    __value_type(__first),
                    __distance_type(__first));
}

template <class _RandomAccessIter, class _Compare>
inline void stable_sort(_RandomAccessIter __first,
                        _RandomAccessIter __last, _Compare __comp) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  __stable_sort_aux(__first, __last,
                    __value_type(__first),
                    __distance_type(__first),
                    __comp);
}



template <class _RandomAccessIter, class _Tp>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*) {
  make_heap(__first, __middle);
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (*__i < *__first)
      __pop_heap(__first, __middle, __i, _Tp(*__i),
                 __distance_type(__first));
  sort_heap(__first, __middle);
}

template <class _RandomAccessIter>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __partial_sort(__first, __middle, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,
                    _RandomAccessIter __last, _Tp*, _Compare __comp) {
  make_heap(__first, __middle, __comp);
  for (_RandomAccessIter __i = __middle; __i < __last; ++__i)
    if (__comp(*__i, *__first))
      __pop_heap(__first, __middle, __i, _Tp(*__i), __comp,
                 __distance_type(__first));
  sort_heap(__first, __middle, __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void partial_sort(_RandomAccessIter __first,
                         _RandomAccessIter __middle,
                         _RandomAccessIter __last, _Compare __comp) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  __partial_sort(__first, __middle, __last, __value_type(__first), __comp);
}

template <class _InputIter, class _RandomAccessIter, class _Distance,
          class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                      _InputIter __last,
                                      _RandomAccessIter __result_first,
                                      _RandomAccessIter __result_last,
                                      _Distance*, _Tp*) {
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last);
  while (__first != __last) {
    if (*__first < *__result_first)
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first));
    ++__first;
  }
  sort_heap(__result_first, __result_real_last);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter>::value_type , typename iterator_traits<_RandomAccessIter>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_InputIter>::value_type , typename iterator_traits<_RandomAccessIter>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  do { void (*__x)( typename iterator_traits<_InputIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  return __partial_sort_copy(__first, __last, __result_first, __result_last,
                             __distance_type(__result_first),
                             __value_type(__first));
}

template <class _InputIter, class _RandomAccessIter, class _Compare,
          class _Distance, class _Tp>
_RandomAccessIter __partial_sort_copy(_InputIter __first,
                                         _InputIter __last,
                                         _RandomAccessIter __result_first,
                                         _RandomAccessIter __result_last,
                                         _Compare __comp, _Distance*, _Tp*) {
  if (__result_first == __result_last) return __result_last;
  _RandomAccessIter __result_real_last = __result_first;
  while(__first != __last && __result_real_last != __result_last) {
    *__result_real_last = *__first;
    ++__result_real_last;
    ++__first;
  }
  make_heap(__result_first, __result_real_last, __comp);
  while (__first != __last) {
    if (__comp(*__first, *__result_first))
      __adjust_heap(__result_first, _Distance(0),
                    _Distance(__result_real_last - __result_first),
                    _Tp(*__first),
                    __comp);
    ++__first;
  }
  sort_heap(__result_first, __result_real_last, __comp);
  return __result_real_last;
}

template <class _InputIter, class _RandomAccessIter, class _Compare>
inline _RandomAccessIter
partial_sort_copy(_InputIter __first, _InputIter __last,
                  _RandomAccessIter __result_first,
                  _RandomAccessIter __result_last, _Compare __comp) {
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter>::value_type , typename iterator_traits<_RandomAccessIter>::value_type ) = _STL_CONVERT_ERROR< typename iterator_traits<_InputIter>::value_type , typename iterator_traits<_RandomAccessIter>::value_type >::__type_X_is_not_convertible_to_type_Y; __x = __x; } while (0);

  do { bool (*__x)( _Compare&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  return __partial_sort_copy(__first, __last, __result_first, __result_last,
                             __comp,
                             __distance_type(__result_first),
                             __value_type(__first));
}



template <class _RandomAccessIter, class _Tp>
void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                   _RandomAccessIter __last, _Tp*) {
  while (__last - __first > 3) {
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1))));
    if (__cut <= __nth)
      __first = __cut;
    else
      __last = __cut;
  }
  __insertion_sort(__first, __last);
}

template <class _RandomAccessIter>
inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                        _RandomAccessIter __last) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  __nth_element(__first, __nth, __last, __value_type(__first));
}

template <class _RandomAccessIter, class _Tp, class _Compare>
void __nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                   _RandomAccessIter __last, _Tp*, _Compare __comp) {
  while (__last - __first > 3) {
    _RandomAccessIter __cut =
      __unguarded_partition(__first, __last,
                            _Tp(__median(*__first,
                                         *(__first + (__last - __first)/2),
                                         *(__last - 1),
                                         __comp)),
                            __comp);
    if (__cut <= __nth)
      __first = __cut;
    else
      __last = __cut;
  }
  __insertion_sort(__first, __last, __comp);
}

template <class _RandomAccessIter, class _Compare>
inline void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,
                        _RandomAccessIter __last, _Compare __comp) {
  do { void (*__x)( _RandomAccessIter ) = _Mutable_RandomAccessIterator_concept_specification< _RandomAccessIter > ::_Mutable_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  __nth_element(__first, __nth, __last, __value_type(__first), __comp);
}




template <class _ForwardIter, class _Tp, class _Distance>
_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (*__middle < __val) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else
      __len = __half;
  }
  return __first;
}

template <class _ForwardIter, class _Tp>
inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);
  return __lower_bound(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
_ForwardIter __lower_bound(_ForwardIter __first, _ForwardIter __last,
                              const _Tp& __val, _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(*__middle, __val)) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else
      __len = __half;
  }
  return __first;
}

template <class _ForwardIter, class _Tp, class _Compare>
inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val, _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { bool (*__x)( _Compare&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  return __lower_bound(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Distance>
_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__val < *__middle)
      __len = __half;
    else {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}

template <class _ForwardIter, class _Tp>
inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);
  return __upper_bound(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last,
                           const _Tp& __val, _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(__val, *__middle))
      __len = __half;
    else {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
  }
  return __first;
}

template <class _ForwardIter, class _Tp, class _Compare>
inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,
                                const _Tp& __val, _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { bool (*__x)( _Compare&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  return __upper_bound(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Distance>
pair<_ForwardIter, _ForwardIter>
__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
              _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle, __left, __right;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (*__middle < __val) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else if (__val < *__middle)
      __len = __half;
    else {
      __left = lower_bound(__first, __middle, __val);
      advance(__first, __len);
      __right = upper_bound(++__middle, __first, __val);
      return pair<_ForwardIter, _ForwardIter>(__left, __right);
    }
  }
  return pair<_ForwardIter, _ForwardIter>(__first, __first);
}

template <class _ForwardIter, class _Tp>
inline pair<_ForwardIter, _ForwardIter>
equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);
  return __equal_range(__first, __last, __val,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp, class _Compare, class _Distance>
pair<_ForwardIter, _ForwardIter>
__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
              _Compare __comp, _Distance*)
{
  _Distance __len = 0;
  distance(__first, __last, __len);
  _Distance __half;
  _ForwardIter __middle, __left, __right;

  while (__len > 0) {
    __half = __len >> 1;
    __middle = __first;
    advance(__middle, __half);
    if (__comp(*__middle, __val)) {
      __first = __middle;
      ++__first;
      __len = __len - __half - 1;
    }
    else if (__comp(__val, *__middle))
      __len = __half;
    else {
      __left = lower_bound(__first, __middle, __val, __comp);
      advance(__first, __len);
      __right = upper_bound(++__middle, __first, __val, __comp);
      return pair<_ForwardIter, _ForwardIter>(__left, __right);
    }
  }
  return pair<_ForwardIter, _ForwardIter>(__first, __first);
}

template <class _ForwardIter, class _Tp, class _Compare>
inline pair<_ForwardIter, _ForwardIter>
equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,
            _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { bool (*__x)( _Compare&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  return __equal_range(__first, __last, __val, __comp,
                       __distance_type(__first));
}

template <class _ForwardIter, class _Tp>
bool binary_search(_ForwardIter __first, _ForwardIter __last,
                   const _Tp& __val) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { void (*__x)( _Tp ) = _LessThanComparable_concept_specification< _Tp > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);
  _ForwardIter __i = lower_bound(__first, __last, __val);
  return __i != __last && !(__val < *__i);
}

template <class _ForwardIter, class _Tp, class _Compare>
bool binary_search(_ForwardIter __first, _ForwardIter __last,
                   const _Tp& __val,
                   _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _Tp , typename iterator_traits<_ForwardIter>::value_type ) = _STL_SAME_TYPE_ERROR< _Tp, typename iterator_traits<_ForwardIter>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);

  do { bool (*__x)( _Compare&, const _Tp&, const _Tp& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, _Tp, _Tp>::__binary_function_requirement_violation; __x = __x; } while (0);
  _ForwardIter __i = lower_bound(__first, __last, __val, __comp);
  return __i != __last && !__comp(__val, *__i);
}



template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _InputIter2 __last2,
                  _OutputIter __result) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,
                  _InputIter2 __first2, _InputIter2 __last2,
                  _OutputIter __result, _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter1>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter1>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  while (__first1 != __last1 && __first2 != __last2) {
    if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}



template <class _BidirectionalIter, class _Distance>
void __merge_without_buffer(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance __len1, _Distance __len2) {
  if (__len1 == 0 || __len2 == 0)
    return;
  if (__len1 + __len2 == 2) {
    if (*__middle < *__first)
      iter_swap(__first, __middle);
    return;
  }
  _BidirectionalIter __first_cut = __first;
  _BidirectionalIter __second_cut = __middle;
  _Distance __len11 = 0;
  _Distance __len22 = 0;
  if (__len1 > __len2) {
    __len11 = __len1 / 2;
    advance(__first_cut, __len11);
    __second_cut = lower_bound(__middle, __last, *__first_cut);
    distance(__middle, __second_cut, __len22);
  }
  else {
    __len22 = __len2 / 2;
    advance(__second_cut, __len22);
    __first_cut = upper_bound(__first, __middle, *__second_cut);
    distance(__first, __first_cut, __len11);
  }
  _BidirectionalIter __new_middle
    = rotate(__first_cut, __middle, __second_cut);
  __merge_without_buffer(__first, __first_cut, __new_middle,
                         __len11, __len22);
  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
                         __len2 - __len22);
}

template <class _BidirectionalIter, class _Distance, class _Compare>
void __merge_without_buffer(_BidirectionalIter __first,
                            _BidirectionalIter __middle,
                            _BidirectionalIter __last,
                            _Distance __len1, _Distance __len2,
                            _Compare __comp) {
  if (__len1 == 0 || __len2 == 0)
    return;
  if (__len1 + __len2 == 2) {
    if (__comp(*__middle, *__first))
      iter_swap(__first, __middle);
    return;
  }
  _BidirectionalIter __first_cut = __first;
  _BidirectionalIter __second_cut = __middle;
  _Distance __len11 = 0;
  _Distance __len22 = 0;
  if (__len1 > __len2) {
    __len11 = __len1 / 2;
    advance(__first_cut, __len11);
    __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
    distance(__middle, __second_cut, __len22);
  }
  else {
    __len22 = __len2 / 2;
    advance(__second_cut, __len22);
    __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
    distance(__first, __first_cut, __len11);
  }
  _BidirectionalIter __new_middle
    = rotate(__first_cut, __middle, __second_cut);
  __merge_without_buffer(__first, __first_cut, __new_middle, __len11, __len22,
                         __comp);
  __merge_without_buffer(__new_middle, __second_cut, __last, __len1 - __len11,
                         __len2 - __len22, __comp);
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _Distance>
_BidirectionalIter1 __rotate_adaptive(_BidirectionalIter1 __first,
                                      _BidirectionalIter1 __middle,
                                      _BidirectionalIter1 __last,
                                      _Distance __len1, _Distance __len2,
                                      _BidirectionalIter2 __buffer,
                                      _Distance __buffer_size) {
  _BidirectionalIter2 __buffer_end;
  if (__len1 > __len2 && __len2 <= __buffer_size) {
    __buffer_end = copy(__middle, __last, __buffer);
    copy_backward(__first, __middle, __last);
    return copy(__buffer, __buffer_end, __first);
  }
  else if (__len1 <= __buffer_size) {
    __buffer_end = copy(__first, __middle, __buffer);
    copy(__middle, __last, __first);
    return copy_backward(__buffer, __buffer_end, __last);
  }
  else
    return rotate(__first, __middle, __last);
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BidirectionalIter3>
_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
                                     _BidirectionalIter1 __last1,
                                     _BidirectionalIter2 __first2,
                                     _BidirectionalIter2 __last2,
                                     _BidirectionalIter3 __result) {
  if (__first1 == __last1)
    return copy_backward(__first2, __last2, __result);
  if (__first2 == __last2)
    return copy_backward(__first1, __last1, __result);
  --__last1;
  --__last2;
  while (true) {
    if (*__last2 < *__last1) {
      *--__result = *__last1;
      if (__first1 == __last1)
        return copy_backward(__first2, ++__last2, __result);
      --__last1;
    }
    else {
      *--__result = *__last2;
      if (__first2 == __last2)
        return copy_backward(__first1, ++__last1, __result);
      --__last2;
    }
  }
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BidirectionalIter3, class _Compare>
_BidirectionalIter3 __merge_backward(_BidirectionalIter1 __first1,
                                     _BidirectionalIter1 __last1,
                                     _BidirectionalIter2 __first2,
                                     _BidirectionalIter2 __last2,
                                     _BidirectionalIter3 __result,
                                     _Compare __comp) {
  if (__first1 == __last1)
    return copy_backward(__first2, __last2, __result);
  if (__first2 == __last2)
    return copy_backward(__first1, __last1, __result);
  --__last1;
  --__last2;
  while (true) {
    if (__comp(*__last2, *__last1)) {
      *--__result = *__last1;
      if (__first1 == __last1)
        return copy_backward(__first2, ++__last2, __result);
      --__last1;
    }
    else {
      *--__result = *__last2;
      if (__first2 == __last2)
        return copy_backward(__first1, ++__last1, __result);
      --__last2;
    }
  }
}

template <class _BidirectionalIter, class _Distance, class _Pointer>
void __merge_adaptive(_BidirectionalIter __first,
                      _BidirectionalIter __middle,
                      _BidirectionalIter __last,
                      _Distance __len1, _Distance __len2,
                      _Pointer __buffer, _Distance __buffer_size) {
  if (__len1 <= __len2 && __len1 <= __buffer_size) {
    _Pointer __buffer_end = copy(__first, __middle, __buffer);
    merge(__buffer, __buffer_end, __middle, __last, __first);
  }
  else if (__len2 <= __buffer_size) {
    _Pointer __buffer_end = copy(__middle, __last, __buffer);
    __merge_backward(__first, __middle, __buffer, __buffer_end, __last);
  }
  else {
    _BidirectionalIter __first_cut = __first;
    _BidirectionalIter __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2) {
      __len11 = __len1 / 2;
      advance(__first_cut, __len11);
      __second_cut = lower_bound(__middle, __last, *__first_cut);
      distance(__middle, __second_cut, __len22);
    }
    else {
      __len22 = __len2 / 2;
      advance(__second_cut, __len22);
      __first_cut = upper_bound(__first, __middle, *__second_cut);
      distance(__first, __first_cut, __len11);
    }
    _BidirectionalIter __new_middle =
      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
                        __len22, __buffer, __buffer_size);
    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                     __len22, __buffer, __buffer_size);
    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                     __len2 - __len22, __buffer, __buffer_size);
  }
}

template <class _BidirectionalIter, class _Distance, class _Pointer,
          class _Compare>
void __merge_adaptive(_BidirectionalIter __first,
                      _BidirectionalIter __middle,
                      _BidirectionalIter __last,
                      _Distance __len1, _Distance __len2,
                      _Pointer __buffer, _Distance __buffer_size,
                      _Compare __comp) {
  if (__len1 <= __len2 && __len1 <= __buffer_size) {
    _Pointer __buffer_end = copy(__first, __middle, __buffer);
    merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
  }
  else if (__len2 <= __buffer_size) {
    _Pointer __buffer_end = copy(__middle, __last, __buffer);
    __merge_backward(__first, __middle, __buffer, __buffer_end, __last,
                     __comp);
  }
  else {
    _BidirectionalIter __first_cut = __first;
    _BidirectionalIter __second_cut = __middle;
    _Distance __len11 = 0;
    _Distance __len22 = 0;
    if (__len1 > __len2) {
      __len11 = __len1 / 2;
      advance(__first_cut, __len11);
      __second_cut = lower_bound(__middle, __last, *__first_cut, __comp);
      distance(__middle, __second_cut, __len22);
    }
    else {
      __len22 = __len2 / 2;
      advance(__second_cut, __len22);
      __first_cut = upper_bound(__first, __middle, *__second_cut, __comp);
      distance(__first, __first_cut, __len11);
    }
    _BidirectionalIter __new_middle =
      __rotate_adaptive(__first_cut, __middle, __second_cut, __len1 - __len11,
                        __len22, __buffer, __buffer_size);
    __merge_adaptive(__first, __first_cut, __new_middle, __len11,
                     __len22, __buffer, __buffer_size, __comp);
    __merge_adaptive(__new_middle, __second_cut, __last, __len1 - __len11,
                     __len2 - __len22, __buffer, __buffer_size, __comp);
  }
}

template <class _BidirectionalIter, class _Tp, class _Distance>
inline void __inplace_merge_aux(_BidirectionalIter __first,
                                _BidirectionalIter __middle,
                                _BidirectionalIter __last, _Tp*, _Distance*) {
  _Distance __len1 = 0;
  distance(__first, __middle, __len1);
  _Distance __len2 = 0;
  distance(__middle, __last, __len2);

  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
  if (__buf.begin() == 0)
    __merge_without_buffer(__first, __middle, __last, __len1, __len2);
  else
    __merge_adaptive(__first, __middle, __last, __len1, __len2,
                     __buf.begin(), _Distance(__buf.size()));
}

template <class _BidirectionalIter, class _Tp,
          class _Distance, class _Compare>
inline void __inplace_merge_aux(_BidirectionalIter __first,
                                _BidirectionalIter __middle,
                                _BidirectionalIter __last, _Tp*, _Distance*,
                                _Compare __comp) {
  _Distance __len1 = 0;
  distance(__first, __middle, __len1);
  _Distance __len2 = 0;
  distance(__middle, __last, __len2);

  _Temporary_buffer<_BidirectionalIter, _Tp> __buf(__first, __last);
  if (__buf.begin() == 0)
    __merge_without_buffer(__first, __middle, __last, __len1, __len2, __comp);
  else
    __merge_adaptive(__first, __middle, __last, __len1, __len2,
                     __buf.begin(), _Distance(__buf.size()),
                     __comp);
}

template <class _BidirectionalIter>
inline void inplace_merge(_BidirectionalIter __first,
                          _BidirectionalIter __middle,
                          _BidirectionalIter __last) {
  do { void (*__x)( _BidirectionalIter ) = _Mutable_BidirectionalIterator_concept_specification< _BidirectionalIter > ::_Mutable_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_BidirectionalIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_BidirectionalIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __middle || __middle == __last)
    return;
  __inplace_merge_aux(__first, __middle, __last,
                      __value_type(__first), __distance_type(__first));
}

template <class _BidirectionalIter, class _Compare>
inline void inplace_merge(_BidirectionalIter __first,
                          _BidirectionalIter __middle,
                          _BidirectionalIter __last, _Compare __comp) {
  do { void (*__x)( _BidirectionalIter ) = _Mutable_BidirectionalIterator_concept_specification< _BidirectionalIter > ::_Mutable_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_BidirectionalIter>::value_type&, const typename iterator_traits<_BidirectionalIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __middle || __middle == __last)
    return;
  __inplace_merge_aux(__first, __middle, __last,
                      __value_type(__first), __distance_type(__first),
                      __comp);
}






template <class _InputIter1, class _InputIter2>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2)
    if (*__first2 < *__first1)
      return false;
    else if(*__first1 < *__first2)
      ++__first1;
    else
      ++__first1, ++__first2;

  return __first2 == __last2;
}

template <class _InputIter1, class _InputIter2, class _Compare>
bool includes(_InputIter1 __first1, _InputIter1 __last1,
              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first2, *__first1))
      return false;
    else if(__comp(*__first1, *__first2))
      ++__first1;
    else
      ++__first1, ++__first2;

  return __first2 == __last2;
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _InputIter2 __last2,
                      _OutputIter __result) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
    }
    else if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,
                      _InputIter2 __first2, _InputIter2 __last2,
                      _OutputIter __result, _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  while (__first1 != __last1 && __first2 != __last2) {
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
    }
    else if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
    }
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
    }
    ++__result;
  }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2)
      ++__first1;
    else if (*__first2 < *__first1)
      ++__first2;
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
      ++__result;
    }
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,
                             _InputIter2 __first2, _InputIter2 __last2,
                             _OutputIter __result, _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2))
      ++__first1;
    else if (__comp(*__first2, *__first1))
      ++__first2;
    else {
      *__result = *__first1;
      ++__first1;
      ++__first2;
      ++__result;
    }
  return __result;
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
                           _InputIter2 __first2, _InputIter2 __last2,
                           _OutputIter __result) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (*__first2 < *__first1)
      ++__first2;
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first1, __last1, __result);
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,
                           _InputIter2 __first2, _InputIter2 __last2,
                           _OutputIter __result, _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);



  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (__comp(*__first2, *__first1))
      ++__first2;
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first1, __last1, __result);
}

template <class _InputIter1, class _InputIter2, class _OutputIter>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                         _InputIter2 __first2, _InputIter2 __last2,
                         _OutputIter __result) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_InputIter1>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  while (__first1 != __last1 && __first2 != __last2)
    if (*__first1 < *__first2) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (*__first2 < *__first1) {
      *__result = *__first2;
      ++__first2;
      ++__result;
    }
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}

template <class _InputIter1, class _InputIter2, class _OutputIter,
          class _Compare>
_OutputIter
set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,
                         _InputIter2 __first2, _InputIter2 __last2,
                         _OutputIter __result,
                         _Compare __comp) {
  do { void (*__x)( _InputIter1 ) = _InputIterator_concept_specification< _InputIter1 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _InputIter2 ) = _InputIterator_concept_specification< _InputIter2 > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _OutputIter ) = _OutputIterator_concept_specification< _OutputIter > ::_OutputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_InputIter1>::value_type , typename iterator_traits<_InputIter2>::value_type ) = _STL_SAME_TYPE_ERROR< typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type >::__type_X_not_same_as_type_Y; __x = __x; } while (0);


  do { bool (*__x)( _Compare&, const typename iterator_traits<_InputIter1>::value_type&, const typename iterator_traits<_InputIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_InputIter1>::value_type, typename iterator_traits<_InputIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first1, *__first2)) {
      *__result = *__first1;
      ++__first1;
      ++__result;
    }
    else if (__comp(*__first2, *__first1)) {
      *__result = *__first2;
      ++__first2;
      ++__result;
    }
    else {
      ++__first1;
      ++__first2;
    }
  return copy(__first2, __last2, copy(__first1, __last1, __result));
}




template <class _ForwardIter>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__result < *__first)
      __result = __first;
  return __result;
}

template <class _ForwardIter, class _Compare>
_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,
                         _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (__comp(*__result, *__first)) __result = __first;
  return __result;
}

template <class _ForwardIter>
_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (*__first < *__result)
      __result = __first;
  return __result;
}

template <class _ForwardIter, class _Compare>
_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,
                         _Compare __comp) {
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last) return __first;
  _ForwardIter __result = __first;
  while (++__first != __last)
    if (__comp(*__first, *__result))
      __result = __first;
  return __result;
}




template <class _BidirectionalIter>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
  do { void (*__x)( _BidirectionalIter ) = _BidirectionalIterator_concept_specification< _BidirectionalIter > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_BidirectionalIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_BidirectionalIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (*__i < *__ii) {
      _BidirectionalIter __j = __last;
      while (!(*__i < *--__j))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter, class _Compare>
bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                      _Compare __comp) {
  do { void (*__x)( _BidirectionalIter ) = _BidirectionalIterator_concept_specification< _BidirectionalIter > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_BidirectionalIter>::value_type&, const typename iterator_traits<_BidirectionalIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (__comp(*__i, *__ii)) {
      _BidirectionalIter __j = __last;
      while (!__comp(*__i, *--__j))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter>
bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last) {
  do { void (*__x)( _BidirectionalIter ) = _BidirectionalIterator_concept_specification< _BidirectionalIter > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_BidirectionalIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_BidirectionalIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (*__ii < *__i) {
      _BidirectionalIter __j = __last;
      while (!(*--__j < *__i))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}

template <class _BidirectionalIter, class _Compare>
bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,
                      _Compare __comp) {
  do { void (*__x)( _BidirectionalIter ) = _BidirectionalIterator_concept_specification< _BidirectionalIter > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _Compare&, const typename iterator_traits<_BidirectionalIter>::value_type&, const typename iterator_traits<_BidirectionalIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _Compare, bool, typename iterator_traits<_BidirectionalIter>::value_type, typename iterator_traits<_BidirectionalIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last)
    return false;
  _BidirectionalIter __i = __first;
  ++__i;
  if (__i == __last)
    return false;
  __i = __last;
  --__i;

  for(;;) {
    _BidirectionalIter __ii = __i;
    --__i;
    if (__comp(*__ii, *__i)) {
      _BidirectionalIter __j = __last;
      while (!__comp(*--__j, *__i))
        {}
      iter_swap(__i, __j);
      reverse(__ii, __last);
      return true;
    }
    if (__i == __first) {
      reverse(__first, __last);
      return false;
    }
  }
}



template <class _InputIter, class _ForwardIter>
_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
                         _ForwardIter __first2, _ForwardIter __last2)
{
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_InputIter>::value_type&, typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_InputIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);



  for ( ; __first1 != __last1; ++__first1)
    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
      if (*__first1 == *__iter)
        return __first1;
  return __last1;
}

template <class _InputIter, class _ForwardIter, class _BinaryPredicate>
_InputIter find_first_of(_InputIter __first1, _InputIter __last1,
                         _ForwardIter __first2, _ForwardIter __last2,
                         _BinaryPredicate __comp)
{
  do { void (*__x)( _InputIter ) = _InputIterator_concept_specification< _InputIter > ::_InputIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPredicate&, const typename iterator_traits<_InputIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, typename iterator_traits<_InputIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);



  for ( ; __first1 != __last1; ++__first1)
    for (_ForwardIter __iter = __first2; __iter != __last2; ++__iter)
      if (__comp(*__first1, *__iter))
        return __first1;
  return __last1;
}
# 3052 "/opt/gcc3/include/g++-v3/bits/stl_algo.h" 3
template <class _ForwardIter1, class _ForwardIter2>
_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
                         _ForwardIter2 __first2, _ForwardIter2 __last2,
                         forward_iterator_tag, forward_iterator_tag)
{
  if (__first2 == __last2)
    return __last1;
  else {
    _ForwardIter1 __result = __last1;
    while (1) {
      _ForwardIter1 __new_result
        = search(__first1, __last1, __first2, __last2);
      if (__new_result == __last1)
        return __result;
      else {
        __result = __new_result;
        __first1 = __new_result;
        ++__first1;
      }
    }
  }
}

template <class _ForwardIter1, class _ForwardIter2,
          class _BinaryPredicate>
_ForwardIter1 __find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
                         _ForwardIter2 __first2, _ForwardIter2 __last2,
                         forward_iterator_tag, forward_iterator_tag,
                         _BinaryPredicate __comp)
{
  if (__first2 == __last2)
    return __last1;
  else {
    _ForwardIter1 __result = __last1;
    while (1) {
      _ForwardIter1 __new_result
        = search(__first1, __last1, __first2, __last2, __comp);
      if (__new_result == __last1)
        return __result;
      else {
        __result = __new_result;
        __first1 = __new_result;
        ++__first1;
      }
    }
  }
}




template <class _BidirectionalIter1, class _BidirectionalIter2>
_BidirectionalIter1
__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
           bidirectional_iterator_tag, bidirectional_iterator_tag)
{
  do { void (*__x)( _BidirectionalIter1 ) = _BidirectionalIterator_concept_specification< _BidirectionalIter1 > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _BidirectionalIter2 ) = _BidirectionalIterator_concept_specification< _BidirectionalIter2 > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

  _RevIter1 __rlast1(__first1);
  _RevIter2 __rlast2(__first2);
  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                               _RevIter2(__last2), __rlast2);

  if (__rresult == __rlast1)
    return __last1;
  else {
    _BidirectionalIter1 __result = __rresult.base();
    advance(__result, -distance(__first2, __last2));
    return __result;
  }
}

template <class _BidirectionalIter1, class _BidirectionalIter2,
          class _BinaryPredicate>
_BidirectionalIter1
__find_end(_BidirectionalIter1 __first1, _BidirectionalIter1 __last1,
           _BidirectionalIter2 __first2, _BidirectionalIter2 __last2,
           bidirectional_iterator_tag, bidirectional_iterator_tag,
           _BinaryPredicate __comp)
{
  do { void (*__x)( _BidirectionalIter1 ) = _BidirectionalIterator_concept_specification< _BidirectionalIter1 > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _BidirectionalIter2 ) = _BidirectionalIterator_concept_specification< _BidirectionalIter2 > ::_BidirectionalIterator_requirement_violation; __x = __x; } while (0);
  typedef reverse_iterator<_BidirectionalIter1> _RevIter1;
  typedef reverse_iterator<_BidirectionalIter2> _RevIter2;

  _RevIter1 __rlast1(__first1);
  _RevIter2 __rlast2(__first2);
  _RevIter1 __rresult = search(_RevIter1(__last1), __rlast1,
                               _RevIter2(__last2), __rlast2,
                               __comp);

  if (__rresult == __rlast1)
    return __last1;
  else {
    _BidirectionalIter1 __result = __rresult.base();
    advance(__result, -distance(__first2, __last2));
    return __result;
  }
}




template <class _ForwardIter1, class _ForwardIter2>
inline _ForwardIter1
find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
         _ForwardIter2 __first2, _ForwardIter2 __last2)
{
  do { void (*__x)( _ForwardIter1 ) = _ForwardIterator_concept_specification< _ForwardIter1 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _ForwardIterator_concept_specification< _ForwardIter2 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( typename iterator_traits<_ForwardIter1>::value_type&, typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>::__binary_operator_requirement_violation; bool (*__y)( const typename iterator_traits<_ForwardIter1>::value_type&, const typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_OP_EQUAL_ERROR< bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>:: __const_binary_operator_requirement_violation; __y = __y; __x = __x; } while (0);


  return __find_end(__first1, __last1, __first2, __last2,
                    __iterator_category(__first1),
                    __iterator_category(__first2));
}

template <class _ForwardIter1, class _ForwardIter2,
          class _BinaryPredicate>
inline _ForwardIter1
find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,
         _ForwardIter2 __first2, _ForwardIter2 __last2,
         _BinaryPredicate __comp)
{
  do { void (*__x)( _ForwardIter1 ) = _ForwardIterator_concept_specification< _ForwardIter1 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( _ForwardIter2 ) = _ForwardIterator_concept_specification< _ForwardIter2 > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _BinaryPredicate&, const typename iterator_traits<_ForwardIter1>::value_type&, const typename iterator_traits<_ForwardIter2>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _BinaryPredicate, bool, typename iterator_traits<_ForwardIter1>::value_type, typename iterator_traits<_ForwardIter2>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);



  return __find_end(__first1, __last1, __first2, __last2,
                    __iterator_category(__first1),
                    __iterator_category(__first2),
                    __comp);
}





template <class _RandomAccessIter, class _Distance>
bool __is_heap(_RandomAccessIter __first, _Distance __n)
{
  _Distance __parent = 0;
  for (_Distance __child = 1; __child < __n; ++__child) {
    if (__first[__parent] < __first[__child])
      return false;
    if ((__child & 1) == 0)
      ++__parent;
  }
  return true;
}

template <class _RandomAccessIter, class _Distance, class _StrictWeakOrdering>
bool __is_heap(_RandomAccessIter __first, _StrictWeakOrdering __comp,
               _Distance __n)
{
  _Distance __parent = 0;
  for (_Distance __child = 1; __child < __n; ++__child) {
    if (__comp(__first[__parent], __first[__child]))
      return false;
    if ((__child & 1) == 0)
      ++__parent;
  }
  return true;
}

template <class _RandomAccessIter>
inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last)
{
  do { void (*__x)( _RandomAccessIter ) = _RandomAccessIterator_concept_specification< _RandomAccessIter > ::_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_RandomAccessIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_RandomAccessIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  return __is_heap(__first, __last - __first);
}


template <class _RandomAccessIter, class _StrictWeakOrdering>
inline bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,
                    _StrictWeakOrdering __comp)
{
  do { void (*__x)( _RandomAccessIter ) = _RandomAccessIterator_concept_specification< _RandomAccessIter > ::_RandomAccessIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _StrictWeakOrdering&, const typename iterator_traits<_RandomAccessIter>::value_type&, const typename iterator_traits<_RandomAccessIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _StrictWeakOrdering, bool, typename iterator_traits<_RandomAccessIter>::value_type, typename iterator_traits<_RandomAccessIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  return __is_heap(__first, __comp, __last - __first);
}





template <class _ForwardIter>
bool is_sorted(_ForwardIter __first, _ForwardIter __last)
{
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { void (*__x)( typename iterator_traits<_ForwardIter>::value_type ) = _LessThanComparable_concept_specification< typename iterator_traits<_ForwardIter>::value_type > ::_LessThanComparable_requirement_violation; __x = __x; } while (0);

  if (__first == __last)
    return true;

  _ForwardIter __next = __first;
  for (++__next; __next != __last; __first = __next, ++__next) {
    if (*__next < *__first)
      return false;
  }

  return true;
}

template <class _ForwardIter, class _StrictWeakOrdering>
bool is_sorted(_ForwardIter __first, _ForwardIter __last,
               _StrictWeakOrdering __comp)
{
  do { void (*__x)( _ForwardIter ) = _ForwardIterator_concept_specification< _ForwardIter > ::_ForwardIterator_requirement_violation; __x = __x; } while (0);
  do { bool (*__x)( _StrictWeakOrdering&, const typename iterator_traits<_ForwardIter>::value_type&, const typename iterator_traits<_ForwardIter>::value_type& ) = _STL_BINARY_FUNCTION_ERROR< _StrictWeakOrdering, bool, typename iterator_traits<_ForwardIter>::value_type, typename iterator_traits<_ForwardIter>::value_type>::__binary_function_requirement_violation; __x = __x; } while (0);


  if (__first == __last)
    return true;

  _ForwardIter __next = __first;
  for (++__next; __next != __last; __first = __next, ++__next) {
    if (__comp(*__next, *__first))
      return false;
  }

  return true;
}





}
# 35 "/opt/gcc3/include/g++-v3/bits/std_algorithm.h" 2 3
# 47 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/basic_string.tcc" 1 3
# 43 "/opt/gcc3/include/g++-v3/bits/basic_string.tcc" 3
namespace std
{
  template<typename _CharT, typename _Traits, typename _Alloc>
    const _CharT
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_terminal = _CharT();

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    _Rep::_S_max_size = (((npos - sizeof(_Rep))/sizeof(_CharT)) - 1) / 4;

  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;



  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::_S_empty_rep_storage[
    (sizeof(_Rep) + sizeof(_CharT) + sizeof(size_type) - 1)/sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIter>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   input_iterator_tag)
      {
        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();

        _CharT __buf[100];
        size_type __i = 0;
        while (__beg != __end && __i < sizeof(__buf) / sizeof(_CharT))
          {
            __buf[__i++] = *__beg;
            ++__beg;
          }
        _Rep* __r = _Rep::_S_create(__i, __a);
        traits_type::copy(__r->_M_refdata(), __buf, __i);
        __r->_M_length = __i;
        try {



          for (;;)
            {
              _CharT* __p = __r->_M_refdata() + __r->_M_length;
              _CharT* __last = __r->_M_refdata() + __r->_M_capacity;
              for (;;)
                {
                  if (__beg == __end)
                    {
                      __r->_M_length = __p - __r->_M_refdata();
                      *__p = _Rep::_S_terminal;
                      return __r->_M_refdata();
                    }
                  if (__p == __last)
                    break;
                  *__p++ = *__beg;
                  ++__beg;
                }

              size_type __len = __p - __r->_M_refdata();
              _Rep* __another = _Rep::_S_create(__len + 1, __a);
              traits_type::copy(__another->_M_refdata(),
                                __r->_M_refdata(), __len);
              __r->_M_destroy(__a);
              __r = __another;
              __r->_M_length = __len;
            }
        }
        catch (...) {
            __r->_M_destroy(__a);
            throw;
        }
        return 0;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <class _InIter>
      _CharT*
      basic_string<_CharT,_Traits,_Alloc>::
      _S_construct(_InIter __beg, _InIter __end, const _Alloc& __a,
                   forward_iterator_tag)
      {
        size_type __dnew = static_cast<size_type>(distance(__beg, __end));

        if (__beg == __end && __a == _Alloc())
          return _S_empty_rep()._M_refcopy();


        _Rep* __r = _Rep::_S_create(__dnew, __a);
        try {
          _S_copy_chars(__r->_M_refdata(), __beg, __end);
        }
        catch (...) {
          __r->_M_destroy(__a);
          throw;
        }
        __r->_M_length = __dnew;

        __r->_M_refdata()[__dnew] = _Rep::_S_terminal;
        return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT,_Traits, _Alloc>::
    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
    {
      if (__n == 0 && __a == _Alloc())
        return _S_empty_rep()._M_refcopy();


      _Rep* __r = _Rep::_S_create(__n, __a);
      try {
        if (__n)
          traits_type::assign(__r->_M_refdata(), __n, __c);
      }
      catch (...) {
        __r->_M_destroy(__a);
        throw;
      }
      __r->_M_length = __n;
      __r->_M_refdata()[__n] = _Rep::_S_terminal;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str)
    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(), __str.get_allocator()),
                 __str.get_allocator())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _Alloc& __a)
    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos, size_type __n)
    : _M_dataplus(_S_construct(__str._M_check(__pos),
                               __str._M_fold(__pos, __n), _Alloc()), _Alloc())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos,
                 size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__str._M_check(__pos),
                               __str._M_fold(__pos, __n), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + traits_type::length(__s), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
    : _M_dataplus(_S_construct(__n, __c, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIter>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIter __beg, _InputIter __end, const _Alloc& __a)
    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::assign(const basic_string& __str)
    {
      if (_M_rep() != __str._M_rep())
        {

          allocator_type __a = this->get_allocator();
          _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
          _M_rep()->_M_dispose(__a);
          _M_data(__tmp);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_destroy(const _Alloc& __a) throw ()
    {
      size_type __size = sizeof(_Rep) + (_M_capacity + 1) * sizeof(_CharT);
      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_M_leak_hard()
    {
      if (_M_rep()->_M_is_shared())
        _M_mutate(0, 0, 0);
      _M_rep()->_M_set_leaked();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
    {
      size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;
      const _CharT* __src = _M_data() + __pos + __len1;
      const size_type __how_much = __old_size - __pos - __len1;

      if (_M_rep()->_M_is_shared() || __new_size > capacity())
        {

          allocator_type __a = get_allocator();
          _Rep* __r = _Rep::_S_create(__new_size, __a);
          try {
            if (__pos)
              traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
            if (__how_much)
              traits_type::copy(__r->_M_refdata() + __pos + __len2,
                                __src, __how_much);
          }
          catch (...) {
            __r->_M_dispose(get_allocator());
            throw;
          }
          _M_rep()->_M_dispose(__a);
          _M_data(__r->_M_refdata());
      }
      else if (__how_much && __len1 != __len2)
        {

          traits_type::move(_M_data() + __pos + __len2, __src, __how_much);
        }
      _M_rep()->_M_set_sharable();
      _M_rep()->_M_length = __new_size;
      _M_data()[__new_size] = _Rep::_S_terminal;

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::reserve(size_type __res)
    {
      if (__res > this->capacity() || _M_rep()->_M_is_shared())
        {
          do { if (__res > this->max_size()) __length_error("__res > this->max_size()"); } while (0);
          allocator_type __a = get_allocator();
          _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
          _M_rep()->_M_dispose(__a);
          _M_data(__tmp);
        }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void basic_string<_CharT, _Traits, _Alloc>::swap(basic_string& __s)
    {
      if (_M_rep()->_M_is_leaked())
        _M_rep()->_M_set_sharable();
      if (__s._M_rep()->_M_is_leaked())
        __s._M_rep()->_M_set_sharable();
      if (this->get_allocator() == __s.get_allocator())
        {
          _CharT* __tmp = _M_data();
          _M_data(__s._M_data());
          __s._M_data(__tmp);
        }

      else
        {
          basic_string __tmp1(_M_ibegin(), _M_iend(), __s.get_allocator());
          basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
                              this->get_allocator());
          *this = __tmp2;
          __s = __tmp1;
        }
    }
# 349 "/opt/gcc3/include/g++-v3/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::_Rep*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_create(size_t __capacity, const _Alloc& __alloc)
    {


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      do { if (__capacity > _S_max_size) __length_error("__capacity > _S_max_size"); } while (0);







      size_t __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);


      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
      _Rep *__p = new (__place) _Rep;
      __p->_M_capacity = __capacity;
      __p->_M_set_sharable();
      __p->_M_length = 0;
      return __p;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_clone(const _Alloc& __alloc, size_type __res)
    {
      _Rep* __r = _Rep::_S_create(_M_length + __res, __alloc);
      if (_M_length)
        {
          try {
            traits_type::copy(__r->_M_refdata(), _M_refdata(), _M_length);
          }
          catch (...) {
            __r->_M_destroy(__alloc);
            throw;
          }
        }
      __r->_M_length = _M_length;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
  inline bool




    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_excess_slop(size_t __s, size_t __r)

    {
      return 2 * (__s <= 16 ? 16 : __s) < __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
    {
      do { if (__n > max_size()) __length_error("__n > max_size()"); } while (0);
      size_type __size = this->size();
      if (__size < __n)
        this->append(__n - __size, __c);
      else if (__n < __size)
        this->erase(__n);

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace(iterator __i1, iterator __i2, _InputIter __k1,
                 _InputIter __k2, input_iterator_tag)
      {
        basic_string __s(__k1, __k2);
        return this->replace(__i1, __i2, __s._M_ibegin(), __s._M_iend());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _ForwardIter>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace(iterator __i1, iterator __i2, _ForwardIter __k1,
                 _ForwardIter __k2, forward_iterator_tag)
      {
        size_type __dold = __i2 - __i1;
        size_type __dmax = this->max_size();
        size_type __dnew = static_cast<size_type>(distance(__k1, __k2));

        do { if (__dmax <= __dnew) __length_error("__dmax <= __dnew"); } while (0);
        size_type __off = __i1 - _M_ibegin();
        _M_mutate(__off, __dold, __dnew);

        if (__dnew)
          _S_copy_chars(_M_data() + __off, __k1, __k2);

        return *this;
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(size_type __pos1, size_type __n1, const basic_string& __str,
            size_type __pos2, size_type __n2)
    {
      return this->replace(_M_check(__pos1), _M_fold(__pos1, __n1),
                           __str._M_check(__pos2),
                           __str._M_fold(__pos2, __n2));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const basic_string& __str)
    {



      size_type __size = __str.size();
      size_type __len = __size + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __str._M_ibegin(),
                           __str._M_iend());
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const basic_string& __str, size_type __pos, size_type __n)
    {



      size_type __len = min(__str.size() - __pos, __n) + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __str._M_check(__pos),
                           __str._M_fold(__pos, __n));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(const _CharT* __s, size_type __n)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
      return this->replace(_M_iend(), _M_iend(), __s, __s + __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>&
    basic_string<_CharT,_Traits,_Alloc>::
    append(size_type __n, _CharT __c)
    {
      size_type __len = __n + this->size();
      if (__len > this->capacity())
        this->reserve(__len);
       return this->replace(_M_iend(), _M_iend(), __n, __c);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
             const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT,_Traits,_Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__lhs, __lhs + __len);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT,_Traits,_Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;
      __string_type __str;
      __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__string_type::size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    replace(iterator __i1, iterator __i2, size_type __n2, _CharT __c)
    {
      size_type __n1 = __i2 - __i1;
      size_type __off1 = __i1 - _M_ibegin();
      do { if (max_size() - (this->size() - __n1) <= __n2) __length_error("max_size() - (this->size() - __n1) <= __n2"); } while (0);
      _M_mutate (__off1, __n1, __n2);

      if (__n2)
        traits_type::assign(_M_data() + __off1, __n2, __c);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      do { if (__pos > this->size()) __out_of_range("__pos > this->size()"); } while (0);

      if (__n > this->size() - __pos)
        __n = this->size() - __pos;

      traits_type::copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      size_t __xpos = __pos;
      const _CharT* __data = _M_data();
      for (; __xpos + __n <= __size; ++__xpos)
        if (traits_type::compare(__data + __xpos, __s, __n) == 0)
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      size_type __ret = npos;
      if (__pos < __size)
        {
          const _CharT* __data = _M_data();
          size_type __n = __size - __pos;
          const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
          if (__p)
            __ret = __p - __data;
        }
      return __ret;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__n <= __size)
        {
          __pos = std::min(__size - __n ,__pos);
          const _CharT* __data = _M_data();
          do
            {
              if (traits_type::compare(__data + __pos, __s, __n) == 0)
                return __pos;
            }
          while (__pos-- > 0);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
        {
          size_t __xpos = __size - 1;
          if (__xpos > __pos)
            __xpos = __pos;

          for (++__xpos; __xpos-- > 0; )
            if (traits_type::eq(_M_data()[__xpos], __c))
              return __xpos;
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      for (; __n && __pos < this->size(); ++__pos)
        {
          const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
          if (__p)
            return __pos;
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__size && __n)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
            }
          while (__size-- != 0);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_t __xpos = __pos;
      for (; __n && __xpos < this->size(); ++__xpos)
        if (!traits_type::find(__s, __n, _M_data()[__xpos]))
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const
    {
      size_t __xpos = __pos;
      for (; __xpos < this->size(); ++__xpos)
        if (!traits_type::eq(_M_data()[__xpos], __c))
          return __xpos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    {
      size_type __size = this->size();
      if (__size && __n)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (!traits_type::find(__s, __n, _M_data()[__size]))
                return __size;
            }
          while (__size--);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const
    {
      size_type __size = this->size();
      if (__size)
        {
          if (--__size > __pos)
            __size = __pos;
          do
            {
              if (!traits_type::eq(_M_data()[__size], __c))
                return __size;
            }
          while (__size--);
        }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos, size_type __n, const basic_string& __str) const
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      do { if (__pos > __size) __out_of_range("__pos > __size"); } while (0);

      size_type __rsize= min(__size - __pos, __n);
      size_type __len = min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
        __r = __rsize - __osize;
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(size_type __pos1, size_type __n1, const basic_string& __str,
            size_type __pos2, size_type __n2) const
    {
      size_type __size = this->size();
      size_type __osize = __str.size();
      do { if (__pos1 > __size) __out_of_range("__pos1 > __size"); } while (0);
      do { if (__pos2 > __osize) __out_of_range("__pos2 > __osize"); } while (0);

      size_type __rsize = min(__size - __pos1, __n1);
      size_type __rosize = min(__osize - __pos2, __n2);
      size_type __len = min(__rsize, __rosize);
      int __r = traits_type::compare(_M_data() + __pos1,
                                     __str.data() + __pos2, __len);
      if (!__r)
        __r = __rsize - __rosize;
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      size_type __size = this->size();
      int __r = traits_type::compare(_M_data(), __s, __size);
      if (!__r)
        __r = __size - traits_type::length(__s);
      return __r;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string <_CharT,_Traits,_Alloc>::
    compare(size_type __pos, size_type __n1, const _CharT* __s,
            size_type __n2) const
    {
      size_type __size = this->size();
      do { if (__pos > __size) __out_of_range("__pos > __size"); } while (0);

      size_type __osize = min(traits_type::length(__s), __n2);
      size_type __rsize = min(__size - __pos, __n1);
      size_type __len = min(__rsize, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
        __r = __rsize - __osize;
      return __r;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    _S_string_copy(const basic_string<_CharT, _Traits, _Alloc>& __str,
                   _CharT* __buf, typename _Alloc::size_type __bufsiz)
    {
      typedef typename _Alloc::size_type size_type;
      size_type __strsize = __str.size();
      size_type __bytes = min(__strsize, __bufsiz - 1);
      _Traits::copy(__buf, __str.data(), __bytes);
      __buf[__bytes] = _CharT();
    }

}
# 48 "/opt/gcc3/include/g++-v3/bits/std_string.h" 2 3
# 3 "/opt/gcc3/include/g++-v3/string" 2 3
# 132 "../include/CORBA.h" 2
# 1 "/opt/gcc3/include/g++-v3/vector" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 1 3
# 30 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_range_errors.h" 1 3
# 25 "/opt/gcc3/include/g++-v3/bits/stl_range_errors.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 26 "/opt/gcc3/include/g++-v3/bits/stl_range_errors.h" 2 3
# 40 "/opt/gcc3/include/g++-v3/bits/stl_range_errors.h" 3
namespace std {
void __stl_throw_range_error(const char* __msg);
void __stl_throw_length_error(const char* __msg);
}
# 31 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 1 3
# 32 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 1 3
# 33 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/exception_support.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 2 3

# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 2 3

namespace std {
# 54 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
template <class _Tp, class _Allocator, bool _IsStatic>
class _Vector_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Vector_alloc_base(const allocator_type& __a)
    : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
  {}

protected:
  allocator_type _M_data_allocator;
  _Tp* _M_start;
  _Tp* _M_finish;
  _Tp* _M_end_of_storage;

  _Tp* _M_allocate(size_t __n)
    { return _M_data_allocator.allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n)
    { if (__p) _M_data_allocator.deallocate(__p, __n); }
};



template <class _Tp, class _Allocator>
class _Vector_alloc_base<_Tp, _Allocator, true> {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Vector_alloc_base(const allocator_type&)
    : _M_start(0), _M_finish(0), _M_end_of_storage(0)
  {}

protected:
  _Tp* _M_start;
  _Tp* _M_finish;
  _Tp* _M_end_of_storage;

  typedef typename _Alloc_traits<_Tp, _Allocator>::_Alloc_type _Alloc_type;
  _Tp* _M_allocate(size_t __n)
    { return _Alloc_type::allocate(__n); }
  void _M_deallocate(_Tp* __p, size_t __n)
    { _Alloc_type::deallocate(__p, __n);}
};

template <class _Tp, class _Alloc>
struct _Vector_base
  : public _Vector_alloc_base<_Tp, _Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
  typedef _Vector_alloc_base<_Tp, _Alloc,
                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;

  _Vector_base(const allocator_type& __a) : _Base(__a) {}
  _Vector_base(size_t __n, const allocator_type& __a) : _Base(__a) {
    _M_start = _M_allocate(__n);
    _M_finish = _M_start;
    _M_end_of_storage = _M_start + __n;
  }

  ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
};
# 156 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
template <class _Tp, class _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc>
{


  typedef void (* __func_Tp_Assignable)( _Tp ); template <__func_Tp_Assignable _Tp1> struct __dummy_struct__Tp_Assignable { }; static __dummy_struct__Tp_Assignable< _Assignable_concept_specification< _Tp>::_Assignable_requirement_violation> __dummy_ptr__Tp_Assignable;

private:
  typedef _Vector_base<_Tp, _Alloc> _Base;
  typedef vector<_Tp, _Alloc> vector_type;
public:
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef __normal_iterator<pointer, vector_type> iterator;
  typedef __normal_iterator<const_pointer, vector_type> const_iterator;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }


  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;







protected:

  using _Base::_M_allocate;
  using _Base::_M_deallocate;
  using _Base::_M_start;
  using _Base::_M_finish;
  using _Base::_M_end_of_storage;


protected:
  void _M_insert_aux(iterator __position, const _Tp& __x);
  void _M_insert_aux(iterator __position);

public:
  iterator begin() { return iterator (_M_start); }
  const_iterator begin() const
    { return const_iterator (_M_start); }
  iterator end() { return iterator (_M_finish); }
  const_iterator end() const { return const_iterator (_M_finish); }

  reverse_iterator rbegin()
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const
    { return const_reverse_iterator(end()); }
  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  size_type size() const
    { return size_type(end() - begin()); }
  size_type max_size() const
    { return size_type(-1) / sizeof(_Tp); }
  size_type capacity() const
    { return size_type(const_iterator(_M_end_of_storage) - begin()); }
  bool empty() const
    { return begin() == end(); }

  reference operator[](size_type __n) { return *(begin() + __n); }
  const_reference operator[](size_type __n) const { return *(begin() + __n); }


  void _M_range_check(size_type __n) const {
    if (__n >= this->size())
      __out_of_range("vector");
  }

  reference at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }
  const_reference at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }


  explicit vector(const allocator_type& __a = allocator_type())
    : _Base(__a) {}

  vector(size_type __n, const _Tp& __value,
         const allocator_type& __a = allocator_type())
    : _Base(__n, __a)
    { _M_finish = uninitialized_fill_n(_M_start, __n, __value); }

  explicit vector(size_type __n)
    : _Base(__n, allocator_type())
    { _M_finish = uninitialized_fill_n(_M_start, __n, _Tp()); }

  vector(const vector<_Tp, _Alloc>& __x)
    : _Base(__x.size(), __x.get_allocator())
    { _M_finish = uninitialized_copy(__x.begin(), __x.end(), _M_start); }



  template <class _InputIterator>
  vector(_InputIterator __first, _InputIterator __last,
         const allocator_type& __a = allocator_type()) : _Base(__a) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_initialize_aux(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_initialize_aux(_Integer __n, _Integer __value, __true_type) {
    _M_start = _M_allocate(__n);
    _M_end_of_storage = _M_start + __n;
    _M_finish = uninitialized_fill_n(_M_start, __n, __value);
  }

  template <class _InputIterator>
  void _M_initialize_aux(_InputIterator __first, _InputIterator __last,
                         __false_type) {
    _M_range_initialize(__first, __last, __iterator_category(__first));
  }
# 288 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
  ~vector() { destroy(_M_start, _M_finish); }

  vector<_Tp, _Alloc>& operator=(const vector<_Tp, _Alloc>& __x);
  void reserve(size_type __n) {
    if (capacity() < __n) {
      const size_type __old_size = size();
      pointer __tmp = _M_allocate_and_copy(__n, _M_start, _M_finish);
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __tmp;
      _M_finish = __tmp + __old_size;
      _M_end_of_storage = _M_start + __n;
    }
  }






  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }
  void _M_fill_assign(size_type __n, const _Tp& __val);



  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    { _M_fill_assign((size_type) __n, (_Tp) __val); }

  template <class _InputIter>
  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
    { _M_assign_aux(__first, __last, __iterator_category(__first)); }

  template <class _InputIterator>
  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                     input_iterator_tag);

  template <class _ForwardIterator>
  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     forward_iterator_tag);



  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(end() - 1); }
  const_reference back() const { return *(end() - 1); }

  void push_back(const _Tp& __x) {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(end(), __x);
  }
  void push_back() {
    if (_M_finish != _M_end_of_storage) {
      construct(_M_finish);
      ++_M_finish;
    }
    else
      _M_insert_aux(end());
  }
  void swap(vector<_Tp, _Alloc>& __x) {
    std::swap(_M_start, __x._M_start);
    std::swap(_M_finish, __x._M_finish);
    std::swap(_M_end_of_storage, __x._M_end_of_storage);
  }

  iterator insert(iterator __position, const _Tp& __x) {
    size_type __n = __position - begin();
    if (_M_finish != _M_end_of_storage && __position == end()) {
      construct(_M_finish, __x);
      ++_M_finish;
    }
    else
      _M_insert_aux(iterator(__position), __x);
    return begin() + __n;
  }
  iterator insert(iterator __position) {
    size_type __n = __position - begin();
    if (_M_finish != _M_end_of_storage && __position == end()) {
      construct(_M_finish);
      ++_M_finish;
    }
    else
      _M_insert_aux(iterator(__position));
    return begin() + __n;
  }


  template <class _InputIterator>
  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_insert_dispatch(__pos, __first, __last, _Integral());
  }

  template <class _Integer>
  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
                          __true_type)
    { _M_fill_insert(__pos, (size_type) __n, (_Tp) __val); }

  template <class _InputIterator>
  void _M_insert_dispatch(iterator __pos,
                          _InputIterator __first, _InputIterator __last,
                          __false_type) {
    _M_range_insert(__pos, __first, __last, __iterator_category(__first));
  }





  void insert (iterator __pos, size_type __n, const _Tp& __x)
    { _M_fill_insert(__pos, __n, __x); }

  void _M_fill_insert (iterator __pos, size_type __n, const _Tp& __x);

  void pop_back() {
    --_M_finish;
    destroy(_M_finish);
  }
  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, end(), __position);
    --_M_finish;
    destroy(_M_finish);
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    iterator __i(copy(__last, end(), __first));
    destroy(__i, end());
    _M_finish = _M_finish - (__last - __first);
    return __first;
  }

  void resize(size_type __new_size, const _Tp& __x) {
    if (__new_size < size())
      erase(begin() + __new_size, end());
    else
      insert(end(), __new_size - size(), __x);
  }
  void resize(size_type __new_size) { resize(__new_size, _Tp()); }
  void clear() { erase(begin(), end()); }

protected:


  template <class _ForwardIterator>
  pointer _M_allocate_and_copy(size_type __n, _ForwardIterator __first,
                                               _ForwardIterator __last)
{
    pointer __result = _M_allocate(__n);
    try {
      uninitialized_copy(__first, __last, __result);
      return __result;
    }
    catch(...) { _M_deallocate(__result, __n); throw; };
  }
# 469 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
  template <class _InputIterator>
  void _M_range_initialize(_InputIterator __first,
                           _InputIterator __last, input_iterator_tag)
  {
    for ( ; __first != __last; ++__first)
      push_back(*__first);
  }


  template <class _ForwardIterator>
  void _M_range_initialize(_ForwardIterator __first,
                           _ForwardIterator __last, forward_iterator_tag)
  {
    size_type __n = 0;
    distance(__first, __last, __n);
    _M_start = _M_allocate(__n);
    _M_end_of_storage = _M_start + __n;
    _M_finish = uninitialized_copy(__first, __last, _M_start);
  }

  template <class _InputIterator>
  void _M_range_insert(iterator __pos,
                       _InputIterator __first, _InputIterator __last,
                       input_iterator_tag);

  template <class _ForwardIterator>
  void _M_range_insert(iterator __pos,
                       _ForwardIterator __first, _ForwardIterator __last,
                       forward_iterator_tag);


};

template <class _Tp, class _Alloc>
inline bool
operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{
  return __x.size() == __y.size() &&
         equal(__x.begin(), __x.end(), __y.begin());
}

template <class _Tp, class _Alloc>
inline bool
operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(),
                                 __y.begin(), __y.end());
}



template <class _Tp, class _Alloc>
inline void swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{
  __x.swap(__y);
}

template <class _Tp, class _Alloc>
inline bool
operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__x == __y);
}

template <class _Tp, class _Alloc>
inline bool
operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return __y < __x;
}

template <class _Tp, class _Alloc>
inline bool
operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__y < __x);
}

template <class _Tp, class _Alloc>
inline bool
operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) {
  return !(__x < __y);
}



template <class _Tp, class _Alloc>
vector<_Tp,_Alloc>&
vector<_Tp,_Alloc>::operator=(const vector<_Tp, _Alloc>& __x)
{
  if (&__x != this) {
    const size_type __xlen = __x.size();
    if (__xlen > capacity()) {
      pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __tmp;
      _M_end_of_storage = _M_start + __xlen;
    }
    else if (size() >= __xlen) {
      iterator __i(copy(__x.begin(), __x.end(), begin()));
      destroy(__i, end());
    }
    else {
      copy(__x.begin(), __x.begin() + size(), _M_start);
      uninitialized_copy(__x.begin() + size(), __x.end(), _M_finish);
    }
    _M_finish = _M_start + __xlen;
  }
  return *this;
}

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_assign(size_t __n, const value_type& __val)
{
  if (__n > capacity()) {
    vector<_Tp, _Alloc> __tmp(__n, __val, get_allocator());
    __tmp.swap(*this);
  }
  else if (__n > size()) {
    fill(begin(), end(), __val);
    _M_finish = uninitialized_fill_n(_M_finish, __n - size(), __val);
  }
  else
    erase(fill_n(begin(), __n, __val), end());
}



template <class _Tp, class _Alloc> template <class _InputIter>
void vector<_Tp, _Alloc>::_M_assign_aux(_InputIter __first, _InputIter __last,
                                        input_iterator_tag) {
  iterator __cur(begin());
  for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
    *__cur = *__first;
  if (__first == __last)
    erase(__cur, end());
  else
    insert(end(), __first, __last);
}

template <class _Tp, class _Alloc> template <class _ForwardIter>
void
vector<_Tp, _Alloc>::_M_assign_aux(_ForwardIter __first, _ForwardIter __last,
                                   forward_iterator_tag) {
  size_type __len = 0;
  distance(__first, __last, __len);

  if (__len > capacity()) {
    pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
    destroy(_M_start, _M_finish);
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __tmp;
    _M_end_of_storage = _M_finish = _M_start + __len;
  }
  else if (size() >= __len) {
    iterator __new_finish(copy(__first, __last, _M_start));
    destroy(__new_finish, end());
    _M_finish = __new_finish.base();
  }
  else {
    _ForwardIter __mid = __first;
    advance(__mid, size());
    copy(__first, __mid, _M_start);
    _M_finish = uninitialized_copy(__mid, __last, _M_finish);
  }
}



template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position, const _Tp& __x)
{
  if (_M_finish != _M_end_of_storage) {
    construct(_M_finish, *(_M_finish - 1));
    ++_M_finish;
    _Tp __x_copy = __x;
    copy_backward(__position, iterator(_M_finish - 2), iterator(_M_finish- 1));
    *__position = __x_copy;
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
    iterator __new_start(_M_allocate(__len));
    iterator __new_finish(__new_start);
    try {
      __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                        __new_start);
      construct(__new_finish.base(), __x);
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                        __new_finish);
    }
    catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

    destroy(begin(), end());
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start.base();
    _M_finish = __new_finish.base();
    _M_end_of_storage = __new_start.base() + __len;
  }
}

template <class _Tp, class _Alloc>
void
vector<_Tp, _Alloc>::_M_insert_aux(iterator __position)
{
  if (_M_finish != _M_end_of_storage) {
    construct(_M_finish, *(_M_finish - 1));
    ++_M_finish;
    copy_backward(__position, iterator(_M_finish - 2),
                  iterator(_M_finish - 1));
    *__position = _Tp();
  }
  else {
    const size_type __old_size = size();
    const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
    pointer __new_start = _M_allocate(__len);
    pointer __new_finish = __new_start;
    try {
      __new_finish = uninitialized_copy(iterator(_M_start), __position,
                                        __new_start);
      construct(__new_finish);
      ++__new_finish;
      __new_finish = uninitialized_copy(__position, iterator(_M_finish),
                                        __new_finish);
    }
    catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start,__len)); throw; };

    destroy(begin(), end());
    _M_deallocate(_M_start, _M_end_of_storage - _M_start);
    _M_start = __new_start;
    _M_finish = __new_finish;
    _M_end_of_storage = __new_start + __len;
  }
}

template <class _Tp, class _Alloc>
void vector<_Tp, _Alloc>::_M_fill_insert(iterator __position, size_type __n,
                                         const _Tp& __x)
{
  if (__n != 0) {
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
      _Tp __x_copy = __x;
      const size_type __elems_after = end() - __position;
      iterator __old_finish(_M_finish);
      if (__elems_after > __n) {
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        fill(__position, __position + __n, __x_copy);
      }
      else {
        uninitialized_fill_n(_M_finish, __n - __elems_after, __x_copy);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);
        _M_finish += __elems_after;
        fill(__position, __old_finish, __x_copy);
      }
    }
    else {
      const size_type __old_size = size();
      const size_type __len = __old_size + max(__old_size, __n);
      iterator __new_start(_M_allocate(__len));
      iterator __new_finish(__new_start);
      try {
        __new_finish = uninitialized_copy(begin(), __position, __new_start);
        __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
        __new_finish
          = uninitialized_copy(__position, end(), __new_finish);
      }
      catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start.base();
      _M_finish = __new_finish.base();
      _M_end_of_storage = __new_start.base() + __len;
    }
  }
}



template <class _Tp, class _Alloc> template <class _InputIterator>
void
vector<_Tp, _Alloc>::_M_range_insert(iterator __pos,
                                     _InputIterator __first,
                                     _InputIterator __last,
                                     input_iterator_tag)
{
  for ( ; __first != __last; ++__first) {
    __pos = insert(__pos, *__first);
    ++__pos;
  }
}

template <class _Tp, class _Alloc> template <class _ForwardIterator>
void
vector<_Tp, _Alloc>::_M_range_insert(iterator __position,
                                     _ForwardIterator __first,
                                     _ForwardIterator __last,
                                     forward_iterator_tag)
{
  if (__first != __last) {
    size_type __n = 0;
    distance(__first, __last, __n);
    if (size_type(_M_end_of_storage - _M_finish) >= __n) {
      const size_type __elems_after = end() - __position;
      iterator __old_finish(_M_finish);
      if (__elems_after > __n) {
        uninitialized_copy(_M_finish - __n, _M_finish, _M_finish);
        _M_finish += __n;
        copy_backward(__position, __old_finish - __n, __old_finish);
        copy(__first, __last, __position);
      }
      else {
        _ForwardIterator __mid = __first;
        advance(__mid, __elems_after);
        uninitialized_copy(__mid, __last, _M_finish);
        _M_finish += __n - __elems_after;
        uninitialized_copy(__position, __old_finish, _M_finish);
        _M_finish += __elems_after;
        copy(__first, __mid, __position);
      }
    }
    else {
      const size_type __old_size = size();
      const size_type __len = __old_size + max(__old_size, __n);
      iterator __new_start(_M_allocate(__len));
      iterator __new_finish(__new_start);
      try {
        __new_finish = uninitialized_copy(iterator(_M_start),
                                          __position, __new_start);
        __new_finish = uninitialized_copy(__first, __last, __new_finish);
        __new_finish
          = uninitialized_copy(__position, iterator(_M_finish), __new_finish);
      }
      catch(...) { (destroy(__new_start,__new_finish), _M_deallocate(__new_start.base(),__len)); throw; };

      destroy(_M_start, _M_finish);
      _M_deallocate(_M_start, _M_end_of_storage - _M_start);
      _M_start = __new_start.base();
      _M_finish = __new_finish.base();
      _M_end_of_storage = __new_start.base() + __len;
    }
  }
}
# 873 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 3
}
# 36 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
namespace std {

static const int __WORD_BIT = int(8*sizeof(unsigned int));






struct _Bit_reference {
  unsigned int* _M_p;
  unsigned int _M_mask;
  _Bit_reference(unsigned int* __x, unsigned int __y)
    : _M_p(__x), _M_mask(__y) {}

public:
  _Bit_reference() : _M_p(0), _M_mask(0) {}
  operator bool() const { return !(!(*_M_p & _M_mask)); }
  _Bit_reference& operator=(bool __x)
  {
    if (__x) *_M_p |= _M_mask;
    else *_M_p &= ~_M_mask;
    return *this;
  }
  _Bit_reference& operator=(const _Bit_reference& __x)
    { return *this = bool(__x); }
  bool operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }
  bool operator<(const _Bit_reference& __x) const {
    return !bool(*this) && bool(__x);
  }
  void flip() { *_M_p ^= _M_mask; }
};

inline void swap(_Bit_reference __x, _Bit_reference __y)
{
  bool __tmp = __x;
  __x = __y;
  __y = __tmp;
}

struct _Bit_iterator_base : public random_access_iterator<bool, ptrdiff_t>
{
  unsigned int* _M_p;
  unsigned int _M_offset;

  _Bit_iterator_base(unsigned int* __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) {}

  void _M_bump_up() {
    if (_M_offset++ == __WORD_BIT - 1) {
      _M_offset = 0;
      ++_M_p;
    }
  }
  void _M_bump_down() {
    if (_M_offset-- == 0) {
      _M_offset = __WORD_BIT - 1;
      --_M_p;
    }
  }

  void _M_incr(ptrdiff_t __i) {
    difference_type __n = __i + _M_offset;
    _M_p += __n / __WORD_BIT;
    __n = __n % __WORD_BIT;
    if (__n < 0) {
      _M_offset = (unsigned int) __n + __WORD_BIT;
      --_M_p;
    } else
      _M_offset = (unsigned int) __n;
  }

  bool operator==(const _Bit_iterator_base& __i) const {
    return _M_p == __i._M_p && _M_offset == __i._M_offset;
  }
  bool operator<(const _Bit_iterator_base& __i) const {
    return _M_p < __i._M_p || (_M_p == __i._M_p && _M_offset < __i._M_offset);
  }
  bool operator!=(const _Bit_iterator_base& __i) const {
    return !(*this == __i);
  }
  bool operator>(const _Bit_iterator_base& __i) const {
    return __i < *this;
  }
  bool operator<=(const _Bit_iterator_base& __i) const {
    return !(__i < *this);
  }
  bool operator>=(const _Bit_iterator_base& __i) const {
    return !(*this < __i);
  }
};

inline ptrdiff_t
operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) {
  return __WORD_BIT * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset;
}


struct _Bit_iterator : public _Bit_iterator_base
{
  typedef _Bit_reference reference;
  typedef _Bit_reference* pointer;
  typedef _Bit_iterator iterator;

  _Bit_iterator() : _Bit_iterator_base(0, 0) {}
  _Bit_iterator(unsigned int* __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) {}

  reference operator*() const { return reference(_M_p, 1U << _M_offset); }
  iterator& operator++() {
    _M_bump_up();
    return *this;
  }
  iterator operator++(int) {
    iterator __tmp = *this;
    _M_bump_up();
    return __tmp;
  }
  iterator& operator--() {
    _M_bump_down();
    return *this;
  }
  iterator operator--(int) {
    iterator __tmp = *this;
    _M_bump_down();
    return __tmp;
  }
  iterator& operator+=(difference_type __i) {
    _M_incr(__i);
    return *this;
  }
  iterator& operator-=(difference_type __i) {
    *this += -__i;
    return *this;
  }
  iterator operator+(difference_type __i) const {
    iterator __tmp = *this;
    return __tmp += __i;
  }
  iterator operator-(difference_type __i) const {
    iterator __tmp = *this;
    return __tmp -= __i;
  }

  reference operator[](difference_type __i) { return *(*this + __i); }
};

inline _Bit_iterator
operator+(ptrdiff_t __n, const _Bit_iterator& __x) { return __x + __n; }


struct _Bit_const_iterator : public _Bit_iterator_base
{
  typedef bool reference;
  typedef bool const_reference;
  typedef const bool* pointer;
  typedef _Bit_const_iterator const_iterator;

  _Bit_const_iterator() : _Bit_iterator_base(0, 0) {}
  _Bit_const_iterator(unsigned int* __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) {}
  _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) {}

  const_reference operator*() const {
    return _Bit_reference(_M_p, 1U << _M_offset);
  }
  const_iterator& operator++() {
    _M_bump_up();
    return *this;
  }
  const_iterator operator++(int) {
    const_iterator __tmp = *this;
    _M_bump_up();
    return __tmp;
  }
  const_iterator& operator--() {
    _M_bump_down();
    return *this;
  }
  const_iterator operator--(int) {
    const_iterator __tmp = *this;
    _M_bump_down();
    return __tmp;
  }
  const_iterator& operator+=(difference_type __i) {
    _M_incr(__i);
    return *this;
  }
  const_iterator& operator-=(difference_type __i) {
    *this += -__i;
    return *this;
  }
  const_iterator operator+(difference_type __i) const {
    const_iterator __tmp = *this;
    return __tmp += __i;
  }
  const_iterator operator-(difference_type __i) const {
    const_iterator __tmp = *this;
    return __tmp -= __i;
  }
  const_reference operator[](difference_type __i) {
    return *(*this + __i);
  }
};

inline _Bit_const_iterator
operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) { return __x + __n; }
# 251 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
template <class _Allocator, bool __is_static>
class _Bvector_alloc_base {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _M_data_allocator; }

  _Bvector_alloc_base(const allocator_type& __a)
    : _M_data_allocator(__a), _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  unsigned int* _M_bit_alloc(size_t __n)
    { return _M_data_allocator.allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _M_data_allocator.deallocate(_M_start._M_p,
                                   _M_end_of_storage - _M_start._M_p);
  }

  typename _Alloc_traits<unsigned int, _Allocator>::allocator_type
          _M_data_allocator;
  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  unsigned int* _M_end_of_storage;
};


template <class _Allocator>
class _Bvector_alloc_base<_Allocator, true> {
public:
  typedef typename _Alloc_traits<bool, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Bvector_alloc_base(const allocator_type&)
    : _M_start(), _M_finish(), _M_end_of_storage(0) {}

protected:
  typedef typename _Alloc_traits<unsigned int, _Allocator>::_Alloc_type
          _Alloc_type;

  unsigned int* _M_bit_alloc(size_t __n)
    { return _Alloc_type::allocate((__n + __WORD_BIT - 1)/__WORD_BIT); }
  void _M_deallocate() {
    if (_M_start._M_p)
      _Alloc_type::deallocate(_M_start._M_p,
                              _M_end_of_storage - _M_start._M_p);
  }

  _Bit_iterator _M_start;
  _Bit_iterator _M_finish;
  unsigned int* _M_end_of_storage;
};

template <class _Alloc>
class _Bvector_base
  : public _Bvector_alloc_base<_Alloc,
                               _Alloc_traits<bool, _Alloc>::_S_instanceless>
{
  typedef _Bvector_alloc_base<_Alloc,
                              _Alloc_traits<bool, _Alloc>::_S_instanceless>
          _Base;
public:
  typedef typename _Base::allocator_type allocator_type;

  _Bvector_base(const allocator_type& __a) : _Base(__a) {}
  ~_Bvector_base() { _Base::_M_deallocate(); }
};
# 362 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
   }
# 1 "/opt/gcc3/include/g++-v3/bits/stl_vector.h" 1 3
# 364 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 2 3
 namespace std {
# 374 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
template <class _Alloc>
class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
{
public:
  typedef bool value_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Bit_reference reference;
  typedef bool const_reference;
  typedef _Bit_reference* pointer;
  typedef const bool* const_pointer;

  typedef _Bit_iterator iterator;
  typedef _Bit_const_iterator const_iterator;


  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;







  typedef typename _Bvector_base<_Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const {
    return _Bvector_base<_Alloc>::get_allocator();
  }

protected:

  using _Bvector_base<_Alloc>::_M_bit_alloc;
  using _Bvector_base<_Alloc>::_M_deallocate;
  using _Bvector_base<_Alloc>::_M_start;
  using _Bvector_base<_Alloc>::_M_finish;
  using _Bvector_base<_Alloc>::_M_end_of_storage;


protected:
  void _M_initialize(size_type __n) {
    unsigned int* __q = _M_bit_alloc(__n);
    _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
    _M_start = iterator(__q, 0);
    _M_finish = _M_start + difference_type(__n);
  }
  void _M_insert_aux(iterator __position, bool __x) {
    if (_M_finish._M_p != _M_end_of_storage) {
      copy_backward(__position, _M_finish, _M_finish + 1);
      *__position = __x;
      ++_M_finish;
    }
    else {
      size_type __len = size() ? 2 * size() : __WORD_BIT;
      unsigned int* __q = _M_bit_alloc(__len);
      iterator __i = copy(begin(), __position, iterator(__q, 0));
      *__i++ = __x;
      _M_finish = copy(__position, end(), __i);
      _M_deallocate();
      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = iterator(__q, 0);
    }
  }


  template <class _InputIterator>
  void _M_initialize_range(_InputIterator __first, _InputIterator __last,
                           input_iterator_tag) {
    _M_start = iterator();
    _M_finish = iterator();
    _M_end_of_storage = 0;
    for ( ; __first != __last; ++__first)
      push_back(*__first);
  }

  template <class _ForwardIterator>
  void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
                           forward_iterator_tag) {
    size_type __n = 0;
    distance(__first, __last, __n);
    _M_initialize(__n);
    copy(__first, __last, _M_start);
  }

  template <class _InputIterator>
  void _M_insert_range(iterator __pos,
                       _InputIterator __first, _InputIterator __last,
                       input_iterator_tag) {
    for ( ; __first != __last; ++__first) {
      __pos = insert(__pos, *__first);
      ++__pos;
    }
  }

  template <class _ForwardIterator>
  void _M_insert_range(iterator __position,
                       _ForwardIterator __first, _ForwardIterator __last,
                       forward_iterator_tag) {
    if (__first != __last) {
      size_type __n = 0;
      distance(__first, __last, __n);
      if (capacity() - size() >= __n) {
        copy_backward(__position, end(), _M_finish + difference_type(__n));
        copy(__first, __last, __position);
        _M_finish += difference_type(__n);
      }
      else {
        size_type __len = size() + max(size(), __n);
        unsigned int* __q = _M_bit_alloc(__len);
        iterator __i = copy(begin(), __position, iterator(__q, 0));
        __i = copy(__first, __last, __i);
        _M_finish = copy(__position, end(), __i);
        _M_deallocate();
        _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
        _M_start = iterator(__q, 0);
      }
    }
  }



public:
  iterator begin() { return _M_start; }
  const_iterator begin() const { return _M_start; }
  iterator end() { return _M_finish; }
  const_iterator end() const { return _M_finish; }

  reverse_iterator rbegin() { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(end());
  }
  reverse_iterator rend() { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(begin());
  }

  size_type size() const { return size_type(end() - begin()); }
  size_type max_size() const { return size_type(-1); }
  size_type capacity() const {
    return size_type(const_iterator(_M_end_of_storage, 0) - begin());
  }
  bool empty() const { return begin() == end(); }

  reference operator[](size_type __n)
    { return *(begin() + difference_type(__n)); }
  const_reference operator[](size_type __n) const
    { return *(begin() + difference_type(__n)); }


  void _M_range_check(size_type __n) const {
    if (__n >= this->size())
      __stl_throw_range_error("vector<bool>");
  }

  reference at(size_type __n)
    { _M_range_check(__n); return (*this)[__n]; }
  const_reference at(size_type __n) const
    { _M_range_check(__n); return (*this)[__n]; }


  explicit vector(const allocator_type& __a = allocator_type())
    : _Bvector_base<_Alloc>(__a) {}

  vector(size_type __n, bool __value,
            const allocator_type& __a = allocator_type())
    : _Bvector_base<_Alloc>(__a)
  {
    _M_initialize(__n);
    fill(_M_start._M_p, _M_end_of_storage, __value ? ~0 : 0);
  }

  explicit vector(size_type __n)
    : _Bvector_base<_Alloc>(allocator_type())
  {
    _M_initialize(__n);
    fill(_M_start._M_p, _M_end_of_storage, 0);
  }

  vector(const vector& __x) : _Bvector_base<_Alloc>(__x.get_allocator()) {
    _M_initialize(__x.size());
    copy(__x.begin(), __x.end(), _M_start);
  }





  template <class _Integer>
  void _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) {
    _M_initialize(__n);
    fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
  }

  template <class _InputIterator>
  void _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
                              __false_type) {
    _M_initialize_range(__first, __last, __iterator_category(__first));
  }

  template <class _InputIterator>
  vector(_InputIterator __first, _InputIterator __last,
           const allocator_type& __a = allocator_type())
    : _Bvector_base<_Alloc>(__a)
  {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_initialize_dispatch(__first, __last, _Integral());
  }
# 605 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
  ~vector() { }

  vector& operator=(const vector& __x) {
    if (&__x == this) return *this;
    if (__x.size() > capacity()) {
      _M_deallocate();
      _M_initialize(__x.size());
    }
    copy(__x.begin(), __x.end(), begin());
    _M_finish = begin() + difference_type(__x.size());
    return *this;
  }






  void _M_fill_assign(size_t __n, bool __x) {
    if (__n > size()) {
      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
      insert(end(), __n - size(), __x);
    }
    else {
      erase(begin() + __n, end());
      fill(_M_start._M_p, _M_end_of_storage, __x ? ~0 : 0);
    }
  }

  void assign(size_t __n, bool __x) { _M_fill_assign(__n, __x); }



  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    { _M_fill_assign((size_t) __n, (bool) __val); }

  template <class _InputIter>
  void _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
    { _M_assign_aux(__first, __last, __iterator_category(__first)); }

  template <class _InputIterator>
  void _M_assign_aux(_InputIterator __first, _InputIterator __last,
                     input_iterator_tag) {
    iterator __cur = begin();
    for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
      *__cur = *__first;
    if (__first == __last)
      erase(__cur, end());
    else
      insert(end(), __first, __last);
  }

  template <class _ForwardIterator>
  void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
                     forward_iterator_tag) {
    size_type __len = 0;
    distance(__first, __last, __len);
    if (__len < size())
      erase(copy(__first, __last, begin()), end());
    else {
      _ForwardIterator __mid = __first;
      advance(__mid, size());
      copy(__first, __mid, begin());
      insert(end(), __mid, __last);
    }
  }



  void reserve(size_type __n) {
    if (capacity() < __n) {
      unsigned int* __q = _M_bit_alloc(__n);
      _M_finish = copy(begin(), end(), iterator(__q, 0));
      _M_deallocate();
      _M_start = iterator(__q, 0);
      _M_end_of_storage = __q + (__n + __WORD_BIT - 1)/__WORD_BIT;
    }
  }

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(end() - 1); }
  const_reference back() const { return *(end() - 1); }
  void push_back(bool __x) {
    if (_M_finish._M_p != _M_end_of_storage)
      *_M_finish++ = __x;
    else
      _M_insert_aux(end(), __x);
  }
  void swap(vector<bool, _Alloc>& __x) {
    std::swap(_M_start, __x._M_start);
    std::swap(_M_finish, __x._M_finish);
    std::swap(_M_end_of_storage, __x._M_end_of_storage);
  }
  iterator insert(iterator __position, bool __x = bool()) {
    difference_type __n = __position - begin();
    if (_M_finish._M_p != _M_end_of_storage && __position == end())
      *_M_finish++ = __x;
    else
      _M_insert_aux(__position, __x);
    return begin() + __n;
  }




  template <class _Integer>
  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                          __true_type) {
    _M_fill_insert(__pos, __n, __x);
  }

  template <class _InputIterator>
  void _M_insert_dispatch(iterator __pos,
                          _InputIterator __first, _InputIterator __last,
                          __false_type) {
    _M_insert_range(__pos, __first, __last, __iterator_category(__first));
  }

  template <class _InputIterator>
  void insert(iterator __position,
              _InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_insert_dispatch(__position, __first, __last, _Integral());
  }
# 783 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
  void _M_fill_insert(iterator __position, size_type __n, bool __x) {
    if (__n == 0) return;
    if (capacity() - size() >= __n) {
      copy_backward(__position, end(), _M_finish + difference_type(__n));
      fill(__position, __position + difference_type(__n), __x);
      _M_finish += difference_type(__n);
    }
    else {
      size_type __len = size() + max(size(), __n);
      unsigned int* __q = _M_bit_alloc(__len);
      iterator __i = copy(begin(), __position, iterator(__q, 0));
      fill_n(__i, __n, __x);
      _M_finish = copy(__position, end(), __i + difference_type(__n));
      _M_deallocate();
      _M_end_of_storage = __q + (__len + __WORD_BIT - 1)/__WORD_BIT;
      _M_start = iterator(__q, 0);
    }
  }

  void insert(iterator __position, size_type __n, bool __x) {
    _M_fill_insert(__position, __n, __x);
  }

  void pop_back() { --_M_finish; }
  iterator erase(iterator __position) {
    if (__position + 1 != end())
      copy(__position + 1, end(), __position);
      --_M_finish;
    return __position;
  }
  iterator erase(iterator __first, iterator __last) {
    _M_finish = copy(__last, end(), __first);
    return __first;
  }
  void resize(size_type __new_size, bool __x = bool()) {
    if (__new_size < size())
      erase(begin() + difference_type(__new_size), end());
    else
      insert(end(), __new_size - size(), __x);
  }
  void flip() {
    for (unsigned int* __p = _M_start._M_p; __p != _M_end_of_storage; ++__p)
      *__p = ~*__p;
  }

  void clear() { erase(begin(), end()); }
};




typedef vector<bool, alloc> bit_vector;
# 890 "/opt/gcc3/include/g++-v3/ext/stl_bvector.h" 3
}
# 37 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 2 3
# 3 "/opt/gcc3/include/g++-v3/vector" 2 3
# 133 "../include/CORBA.h" 2
# 1 "/opt/gcc3/include/g++-v3/map" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_map.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/bits/std_map.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 1 3
# 56 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 1 3
# 57 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 1 3
# 58 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 1 3
# 59 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_function.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_function.h" 3
namespace std {

template <class _Arg, class _Result>
struct unary_function {
  typedef _Arg argument_type;
  typedef _Result result_type;
};

template <class _Arg1, class _Arg2, class _Result>
struct binary_function {
  typedef _Arg1 first_argument_type;
  typedef _Arg2 second_argument_type;
  typedef _Result result_type;
};

template <class _Tp>
struct plus : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
};

template <class _Tp>
struct minus : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
};

template <class _Tp>
struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
};

template <class _Tp>
struct divides : public binary_function<_Tp,_Tp,_Tp> {
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
};



template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
  return _Tp(0);
}
template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
  return _Tp(1);
}

template <class _Tp>
struct modulus : public binary_function<_Tp,_Tp,_Tp>
{
  _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
};

template <class _Tp>
struct negate : public unary_function<_Tp,_Tp>
{
  _Tp operator()(const _Tp& __x) const { return -__x; }
};

template <class _Tp>
struct equal_to : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
};

template <class _Tp>
struct not_equal_to : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
};

template <class _Tp>
struct greater : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
};

template <class _Tp>
struct less : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
};

template <class _Tp>
struct greater_equal : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
};

template <class _Tp>
struct less_equal : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
};

template <class _Tp>
struct logical_and : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
};

template <class _Tp>
struct logical_or : public binary_function<_Tp,_Tp,bool>
{
  bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
};

template <class _Tp>
struct logical_not : public unary_function<_Tp,bool>
{
  bool operator()(const _Tp& __x) const { return !__x; }
};

template <class _Predicate>
class unary_negate
  : public unary_function<typename _Predicate::argument_type, bool> {
protected:
  _Predicate _M_pred;
public:
  explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::argument_type& __x) const {
    return !_M_pred(__x);
  }
};

template <class _Predicate>
inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{
  return unary_negate<_Predicate>(__pred);
}

template <class _Predicate>
class binary_negate
  : public binary_function<typename _Predicate::first_argument_type,
                           typename _Predicate::second_argument_type,
                           bool> {
protected:
  _Predicate _M_pred;
public:
  explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
  bool operator()(const typename _Predicate::first_argument_type& __x,
                  const typename _Predicate::second_argument_type& __y) const
  {
    return !_M_pred(__x, __y);
  }
};

template <class _Predicate>
inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{
  return binary_negate<_Predicate>(__pred);
}

template <class _Operation>
class binder1st
  : public unary_function<typename _Operation::second_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::first_argument_type value;
public:
  binder1st(const _Operation& __x,
            const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::second_argument_type& __x) const {
    return op(value, __x);
  }
};

template <class _Operation, class _Tp>
inline binder1st<_Operation>
bind1st(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::first_argument_type _Arg1_type;
  return binder1st<_Operation>(__fn, _Arg1_type(__x));
}

template <class _Operation>
class binder2nd
  : public unary_function<typename _Operation::first_argument_type,
                          typename _Operation::result_type> {
protected:
  _Operation op;
  typename _Operation::second_argument_type value;
public:
  binder2nd(const _Operation& __x,
            const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) {}
  typename _Operation::result_type
  operator()(const typename _Operation::first_argument_type& __x) const {
    return op(__x, value);
  }
};

template <class _Operation, class _Tp>
inline binder2nd<_Operation>
bind2nd(const _Operation& __fn, const _Tp& __x)
{
  typedef typename _Operation::second_argument_type _Arg2_type;
  return binder2nd<_Operation>(__fn, _Arg2_type(__x));
}



template <class _Operation1, class _Operation2>
class unary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type>
{
protected:
  _Operation1 _M_fn1;
  _Operation2 _M_fn2;
public:
  unary_compose(const _Operation1& __x, const _Operation2& __y)
    : _M_fn1(__x), _M_fn2(__y) {}
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x));
  }
};

template <class _Operation1, class _Operation2>
inline unary_compose<_Operation1,_Operation2>
compose1(const _Operation1& __fn1, const _Operation2& __fn2)
{
  return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
}

template <class _Operation1, class _Operation2, class _Operation3>
class binary_compose
  : public unary_function<typename _Operation2::argument_type,
                          typename _Operation1::result_type> {
protected:
  _Operation1 _M_fn1;
  _Operation2 _M_fn2;
  _Operation3 _M_fn3;
public:
  binary_compose(const _Operation1& __x, const _Operation2& __y,
                 const _Operation3& __z)
    : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
  typename _Operation1::result_type
  operator()(const typename _Operation2::argument_type& __x) const {
    return _M_fn1(_M_fn2(__x), _M_fn3(__x));
  }
};

template <class _Operation1, class _Operation2, class _Operation3>
inline binary_compose<_Operation1, _Operation2, _Operation3>
compose2(const _Operation1& __fn1, const _Operation2& __fn2,
         const _Operation3& __fn3)
{
  return binary_compose<_Operation1,_Operation2,_Operation3>
    (__fn1, __fn2, __fn3);
}

template <class _Arg, class _Result>
class pointer_to_unary_function : public unary_function<_Arg, _Result> {
protected:
  _Result (*_M_ptr)(_Arg);
public:
  pointer_to_unary_function() {}
  explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
  _Result operator()(_Arg __x) const { return _M_ptr(__x); }
};

template <class _Arg, class _Result>
inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
{
  return pointer_to_unary_function<_Arg, _Result>(__x);
}

template <class _Arg1, class _Arg2, class _Result>
class pointer_to_binary_function :
  public binary_function<_Arg1,_Arg2,_Result> {
protected:
    _Result (*_M_ptr)(_Arg1, _Arg2);
public:
    pointer_to_binary_function() {}
    explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) {}
    _Result operator()(_Arg1 __x, _Arg2 __y) const {
      return _M_ptr(__x, __y);
    }
};

template <class _Arg1, class _Arg2, class _Result>
inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
  return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
}


template <class _Tp>
struct _Identity : public unary_function<_Tp,_Tp> {
  _Tp& operator()(_Tp& __x) const { return __x; }
  const _Tp& operator()(const _Tp& __x) const { return __x; }
};

template <class _Tp> struct identity : public _Identity<_Tp> {};


template <class _Pair>
struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
  typename _Pair::first_type& operator()(_Pair& __x) const {
    return __x.first;
  }
  const typename _Pair::first_type& operator()(const _Pair& __x) const {
    return __x.first;
  }
};

template <class _Pair>
struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
{
  typename _Pair::second_type& operator()(_Pair& __x) const {
    return __x.second;
  }
  const typename _Pair::second_type& operator()(const _Pair& __x) const {
    return __x.second;
  }
};

template <class _Pair> struct select1st : public _Select1st<_Pair> {};
template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};


template <class _Arg1, class _Arg2>
struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
  _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
};

template <class _Arg1, class _Arg2>
struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
  _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
};

template <class _Arg1, class _Arg2>
struct project1st : public _Project1st<_Arg1, _Arg2> {};

template <class _Arg1, class _Arg2>
struct project2nd : public _Project2nd<_Arg1, _Arg2> {};





template <class _Result>
struct _Constant_void_fun {
  typedef _Result result_type;
  result_type _M_val;

  _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
  const result_type& operator()() const { return _M_val; }
};

template <class _Result, class _Argument>
struct _Constant_unary_fun {
  typedef _Argument argument_type;
  typedef _Result result_type;
  result_type _M_val;

  _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
  const result_type& operator()(const _Argument&) const { return _M_val; }
};

template <class _Result, class _Arg1, class _Arg2>
struct _Constant_binary_fun {
  typedef _Arg1 first_argument_type;
  typedef _Arg2 second_argument_type;
  typedef _Result result_type;
  _Result _M_val;

  _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
  const result_type& operator()(const _Arg1&, const _Arg2&) const {
    return _M_val;
  }
};

template <class _Result>
struct constant_void_fun : public _Constant_void_fun<_Result> {
  constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
};


template <class _Result,
          class _Argument = _Result>
struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
{
  constant_unary_fun(const _Result& __v)
    : _Constant_unary_fun<_Result, _Argument>(__v) {}
};


template <class _Result,
          class _Arg1 = _Result,
          class _Arg2 = _Arg1>
struct constant_binary_fun
  : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
{
  constant_binary_fun(const _Result& __v)
    : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
};

template <class _Result>
inline constant_void_fun<_Result> constant0(const _Result& __val)
{
  return constant_void_fun<_Result>(__val);
}

template <class _Result>
inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
{
  return constant_unary_fun<_Result,_Result>(__val);
}

template <class _Result>
inline constant_binary_fun<_Result,_Result,_Result>
constant2(const _Result& __val)
{
  return constant_binary_fun<_Result,_Result,_Result>(__val);
}



class subtractive_rng : public unary_function<unsigned int, unsigned int> {
private:
  unsigned int _M_table[55];
  size_t _M_index1;
  size_t _M_index2;
public:
  unsigned int operator()(unsigned int __limit) {
    _M_index1 = (_M_index1 + 1) % 55;
    _M_index2 = (_M_index2 + 1) % 55;
    _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
    return _M_table[_M_index1] % __limit;
  }

  void _M_initialize(unsigned int __seed)
  {
    unsigned int __k = 1;
    _M_table[54] = __seed;
    size_t __i;
    for (__i = 0; __i < 54; __i++) {
        size_t __ii = (21 * (__i + 1) % 55) - 1;
        _M_table[__ii] = __k;
        __k = __seed - __k;
        __seed = _M_table[__ii];
    }
    for (int __loop = 0; __loop < 4; __loop++) {
        for (__i = 0; __i < 55; __i++)
            _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
    }
    _M_index1 = 0;
    _M_index2 = 31;
  }

  subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
  subtractive_rng() { _M_initialize(161803398u); }
};
# 518 "/opt/gcc3/include/g++-v3/bits/stl_function.h" 3
template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*,_Ret> {
public:
  explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};

template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
public:
  explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};


template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)();
};

template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
public:
  explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
private:
  _Ret (_Tp::*_M_f)() const;
};

template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
public:
  explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
public:
  explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp* __p, _Arg __x) const
    { return (__p->*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};

template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
public:
  explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};



template <class _Tp>
class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
public:
  explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};

template <class _Tp>
class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
public:
  explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};

template <class _Tp>
class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  void operator()(_Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)();
};

template <class _Tp>
class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
public:
  explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
private:
  void (_Tp::*_M_f)() const;
};

template <class _Tp, class _Arg>
class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
public:
  explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};

template <class _Tp, class _Arg>
class const_mem_fun1_t<void, _Tp, _Arg>
  : public binary_function<const _Tp*,_Arg,void> {
public:
  explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};

template <class _Tp, class _Arg>
class mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg);
};

template <class _Tp, class _Arg>
class const_mem_fun1_ref_t<void, _Tp, _Arg>
  : public binary_function<_Tp,_Arg,void> {
public:
  explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
private:
  void (_Tp::*_M_f)(_Arg) const;
};
# 676 "/opt/gcc3/include/g++-v3/bits/stl_function.h" 3
template <class _Ret, class _Tp>
inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
  { return mem_fun_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
  { return const_mem_fun_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)())
  { return mem_fun_ref_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp>
inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
  { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

template <class _Ret, class _Tp, class _Arg>
inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }

}
# 60 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 2 3

namespace std {





typedef bool _Rb_tree_Color_type;
const _Rb_tree_Color_type _S_rb_tree_red = false;
const _Rb_tree_Color_type _S_rb_tree_black = true;

struct _Rb_tree_node_base
{
  typedef _Rb_tree_Color_type _Color_type;
  typedef _Rb_tree_node_base* _Base_ptr;

  _Color_type _M_color;
  _Base_ptr _M_parent;
  _Base_ptr _M_left;
  _Base_ptr _M_right;

  static _Base_ptr _S_minimum(_Base_ptr __x)
  {
    while (__x->_M_left != 0) __x = __x->_M_left;
    return __x;
  }

  static _Base_ptr _S_maximum(_Base_ptr __x)
  {
    while (__x->_M_right != 0) __x = __x->_M_right;
    return __x;
  }
};

template <class _Value>
struct _Rb_tree_node : public _Rb_tree_node_base
{
  typedef _Rb_tree_node<_Value>* _Link_type;
  _Value _M_value_field;
};


struct _Rb_tree_base_iterator
{
  typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
  typedef bidirectional_iterator_tag iterator_category;
  typedef ptrdiff_t difference_type;
  _Base_ptr _M_node;

  void _M_increment()
  {
    if (_M_node->_M_right != 0) {
      _M_node = _M_node->_M_right;
      while (_M_node->_M_left != 0)
        _M_node = _M_node->_M_left;
    }
    else {
      _Base_ptr __y = _M_node->_M_parent;
      while (_M_node == __y->_M_right) {
        _M_node = __y;
        __y = __y->_M_parent;
      }
      if (_M_node->_M_right != __y)
        _M_node = __y;
    }
  }

  void _M_decrement()
  {
    if (_M_node->_M_color == _S_rb_tree_red &&
        _M_node->_M_parent->_M_parent == _M_node)
      _M_node = _M_node->_M_right;
    else if (_M_node->_M_left != 0) {
      _Base_ptr __y = _M_node->_M_left;
      while (__y->_M_right != 0)
        __y = __y->_M_right;
      _M_node = __y;
    }
    else {
      _Base_ptr __y = _M_node->_M_parent;
      while (_M_node == __y->_M_left) {
        _M_node = __y;
        __y = __y->_M_parent;
      }
      _M_node = __y;
    }
  }
};

template <class _Value, class _Ref, class _Ptr>
struct _Rb_tree_iterator : public _Rb_tree_base_iterator
{
  typedef _Value value_type;
  typedef _Ref reference;
  typedef _Ptr pointer;
  typedef _Rb_tree_iterator<_Value, _Value&, _Value*>
    iterator;
  typedef _Rb_tree_iterator<_Value, const _Value&, const _Value*>
    const_iterator;
  typedef _Rb_tree_iterator<_Value, _Ref, _Ptr>
    _Self;
  typedef _Rb_tree_node<_Value>* _Link_type;

  _Rb_tree_iterator() {}
  _Rb_tree_iterator(_Link_type __x) { _M_node = __x; }
  _Rb_tree_iterator(const iterator& __it) { _M_node = __it._M_node; }

  reference operator*() const { return _Link_type(_M_node)->_M_value_field; }

  pointer operator->() const { return &(operator*()); }


  _Self& operator++() { _M_increment(); return *this; }
  _Self operator++(int) {
    _Self __tmp = *this;
    _M_increment();
    return __tmp;
  }

  _Self& operator--() { _M_decrement(); return *this; }
  _Self operator--(int) {
    _Self __tmp = *this;
    _M_decrement();
    return __tmp;
  }
};

template <class _Value, class _Ref, class _Ptr>
inline bool operator==(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x,
                       const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value>
inline bool operator==(const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __x,
                       const _Rb_tree_iterator<_Value, _Value&, _Value*>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value>
inline bool operator==(const _Rb_tree_iterator<_Value, _Value&, _Value*>& __x,
                       const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __y) {
  return __x._M_node == __y._M_node;
}

template <class _Value, class _Ref, class _Ptr>
inline bool operator!=(const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __x,
                       const _Rb_tree_iterator<_Value, _Ref, _Ptr>& __y) {
  return __x._M_node != __y._M_node;
}

template <class _Value>
inline bool operator!=(const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __x,
                       const _Rb_tree_iterator<_Value, _Value&, _Value*>& __y) {
  return __x._M_node != __y._M_node;
}

template <class _Value>
inline bool operator!=(const _Rb_tree_iterator<_Value, _Value&, _Value*>& __x,
                       const _Rb_tree_iterator<_Value, const _Value&, const _Value*>& __y) {
  return __x._M_node != __y._M_node;
}
# 242 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
inline void
_Rb_tree_rotate_left(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  _Rb_tree_node_base* __y = __x->_M_right;
  __x->_M_right = __y->_M_left;
  if (__y->_M_left !=0)
    __y->_M_left->_M_parent = __x;
  __y->_M_parent = __x->_M_parent;

  if (__x == __root)
    __root = __y;
  else if (__x == __x->_M_parent->_M_left)
    __x->_M_parent->_M_left = __y;
  else
    __x->_M_parent->_M_right = __y;
  __y->_M_left = __x;
  __x->_M_parent = __y;
}

inline void
_Rb_tree_rotate_right(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  _Rb_tree_node_base* __y = __x->_M_left;
  __x->_M_left = __y->_M_right;
  if (__y->_M_right != 0)
    __y->_M_right->_M_parent = __x;
  __y->_M_parent = __x->_M_parent;

  if (__x == __root)
    __root = __y;
  else if (__x == __x->_M_parent->_M_right)
    __x->_M_parent->_M_right = __y;
  else
    __x->_M_parent->_M_left = __y;
  __y->_M_right = __x;
  __x->_M_parent = __y;
}

inline void
_Rb_tree_rebalance(_Rb_tree_node_base* __x, _Rb_tree_node_base*& __root)
{
  __x->_M_color = _S_rb_tree_red;
  while (__x != __root && __x->_M_parent->_M_color == _S_rb_tree_red) {
    if (__x->_M_parent == __x->_M_parent->_M_parent->_M_left) {
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_right;
      if (__y && __y->_M_color == _S_rb_tree_red) {
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {
        if (__x == __x->_M_parent->_M_right) {
          __x = __x->_M_parent;
          _Rb_tree_rotate_left(__x, __root);
        }
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_right(__x->_M_parent->_M_parent, __root);
      }
    }
    else {
      _Rb_tree_node_base* __y = __x->_M_parent->_M_parent->_M_left;
      if (__y && __y->_M_color == _S_rb_tree_red) {
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __y->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        __x = __x->_M_parent->_M_parent;
      }
      else {
        if (__x == __x->_M_parent->_M_left) {
          __x = __x->_M_parent;
          _Rb_tree_rotate_right(__x, __root);
        }
        __x->_M_parent->_M_color = _S_rb_tree_black;
        __x->_M_parent->_M_parent->_M_color = _S_rb_tree_red;
        _Rb_tree_rotate_left(__x->_M_parent->_M_parent, __root);
      }
    }
  }
  __root->_M_color = _S_rb_tree_black;
}

inline _Rb_tree_node_base*
_Rb_tree_rebalance_for_erase(_Rb_tree_node_base* __z,
                             _Rb_tree_node_base*& __root,
                             _Rb_tree_node_base*& __leftmost,
                             _Rb_tree_node_base*& __rightmost)
{
  _Rb_tree_node_base* __y = __z;
  _Rb_tree_node_base* __x = 0;
  _Rb_tree_node_base* __x_parent = 0;
  if (__y->_M_left == 0)
    __x = __y->_M_right;
  else
    if (__y->_M_right == 0)
      __x = __y->_M_left;
    else {
      __y = __y->_M_right;
      while (__y->_M_left != 0)
        __y = __y->_M_left;
      __x = __y->_M_right;
    }
  if (__y != __z) {
    __z->_M_left->_M_parent = __y;
    __y->_M_left = __z->_M_left;
    if (__y != __z->_M_right) {
      __x_parent = __y->_M_parent;
      if (__x) __x->_M_parent = __y->_M_parent;
      __y->_M_parent->_M_left = __x;
      __y->_M_right = __z->_M_right;
      __z->_M_right->_M_parent = __y;
    }
    else
      __x_parent = __y;
    if (__root == __z)
      __root = __y;
    else if (__z->_M_parent->_M_left == __z)
      __z->_M_parent->_M_left = __y;
    else
      __z->_M_parent->_M_right = __y;
    __y->_M_parent = __z->_M_parent;
    std::swap(__y->_M_color, __z->_M_color);
    __y = __z;

  }
  else {
    __x_parent = __y->_M_parent;
    if (__x) __x->_M_parent = __y->_M_parent;
    if (__root == __z)
      __root = __x;
    else
      if (__z->_M_parent->_M_left == __z)
        __z->_M_parent->_M_left = __x;
      else
        __z->_M_parent->_M_right = __x;
    if (__leftmost == __z)
      if (__z->_M_right == 0)
        __leftmost = __z->_M_parent;

      else
        __leftmost = _Rb_tree_node_base::_S_minimum(__x);
    if (__rightmost == __z)
      if (__z->_M_left == 0)
        __rightmost = __z->_M_parent;

      else
        __rightmost = _Rb_tree_node_base::_S_maximum(__x);
  }
  if (__y->_M_color != _S_rb_tree_red) {
    while (__x != __root && (__x == 0 || __x->_M_color == _S_rb_tree_black))
      if (__x == __x_parent->_M_left) {
        _Rb_tree_node_base* __w = __x_parent->_M_right;
        if (__w->_M_color == _S_rb_tree_red) {
          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_left(__x_parent, __root);
          __w = __x_parent->_M_right;
        }
        if ((__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black) &&
            (__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black)) {
          __w->_M_color = _S_rb_tree_red;
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_right == 0 ||
              __w->_M_right->_M_color == _S_rb_tree_black) {
            if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_right(__w, __root);
            __w = __x_parent->_M_right;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_left(__x_parent, __root);
          break;
        }
      } else {
        _Rb_tree_node_base* __w = __x_parent->_M_left;
        if (__w->_M_color == _S_rb_tree_red) {
          __w->_M_color = _S_rb_tree_black;
          __x_parent->_M_color = _S_rb_tree_red;
          _Rb_tree_rotate_right(__x_parent, __root);
          __w = __x_parent->_M_left;
        }
        if ((__w->_M_right == 0 ||
             __w->_M_right->_M_color == _S_rb_tree_black) &&
            (__w->_M_left == 0 ||
             __w->_M_left->_M_color == _S_rb_tree_black)) {
          __w->_M_color = _S_rb_tree_red;
          __x = __x_parent;
          __x_parent = __x_parent->_M_parent;
        } else {
          if (__w->_M_left == 0 ||
              __w->_M_left->_M_color == _S_rb_tree_black) {
            if (__w->_M_right) __w->_M_right->_M_color = _S_rb_tree_black;
            __w->_M_color = _S_rb_tree_red;
            _Rb_tree_rotate_left(__w, __root);
            __w = __x_parent->_M_left;
          }
          __w->_M_color = __x_parent->_M_color;
          __x_parent->_M_color = _S_rb_tree_black;
          if (__w->_M_left) __w->_M_left->_M_color = _S_rb_tree_black;
          _Rb_tree_rotate_right(__x_parent, __root);
          break;
        }
      }
    if (__x) __x->_M_color = _S_rb_tree_black;
  }
  return __y;
}
# 465 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
template <class _Tp, class _Alloc, bool _S_instanceless>
class _Rb_tree_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return _M_node_allocator; }

  _Rb_tree_alloc_base(const allocator_type& __a)
    : _M_node_allocator(__a), _M_header(0) {}

protected:
  typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::allocator_type
           _M_node_allocator;
  _Rb_tree_node<_Tp>* _M_header;

  _Rb_tree_node<_Tp>* _M_get_node()
    { return _M_node_allocator.allocate(1); }
  void _M_put_node(_Rb_tree_node<_Tp>* __p)
    { _M_node_allocator.deallocate(__p, 1); }
};


template <class _Tp, class _Alloc>
class _Rb_tree_alloc_base<_Tp, _Alloc, true> {
public:
  typedef typename _Alloc_traits<_Tp, _Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _Rb_tree_alloc_base(const allocator_type&) : _M_header(0) {}

protected:
  _Rb_tree_node<_Tp>* _M_header;

  typedef typename _Alloc_traits<_Rb_tree_node<_Tp>, _Alloc>::_Alloc_type
          _Alloc_type;

  _Rb_tree_node<_Tp>* _M_get_node()
    { return _Alloc_type::allocate(1); }
  void _M_put_node(_Rb_tree_node<_Tp>* __p)
    { _Alloc_type::deallocate(__p, 1); }
};

template <class _Tp, class _Alloc>
struct _Rb_tree_base
  : public _Rb_tree_alloc_base<_Tp, _Alloc,
                               _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
  typedef _Rb_tree_alloc_base<_Tp, _Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;

  _Rb_tree_base(const allocator_type& __a)
    : _Base(__a) { _M_header = _M_get_node(); }
  ~_Rb_tree_base() { _M_put_node(_M_header); }

};
# 547 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
template <class _Key, class _Value, class _KeyOfValue, class _Compare,
          class _Alloc = allocator<_Value> >
class _Rb_tree : protected _Rb_tree_base<_Value, _Alloc> {
  typedef _Rb_tree_base<_Value, _Alloc> _Base;
protected:
  typedef _Rb_tree_node_base* _Base_ptr;
  typedef _Rb_tree_node<_Value> _Rb_tree_node;
  typedef _Rb_tree_Color_type _Color_type;
public:
  typedef _Key key_type;
  typedef _Value value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef _Rb_tree_node* _Link_type;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

protected:

  using _Base::_M_get_node;
  using _Base::_M_put_node;
  using _Base::_M_header;


protected:

  _Link_type _M_create_node(const value_type& __x)
  {
    _Link_type __tmp = _M_get_node();
    try {
      construct(&__tmp->_M_value_field, __x);
    }
    catch(...) { _M_put_node(__tmp); throw; };
    return __tmp;
  }

  _Link_type _M_clone_node(_Link_type __x)
  {
    _Link_type __tmp = _M_create_node(__x->_M_value_field);
    __tmp->_M_color = __x->_M_color;
    __tmp->_M_left = 0;
    __tmp->_M_right = 0;
    return __tmp;
  }

  void destroy_node(_Link_type __p)
  {
    destroy(&__p->_M_value_field);
    _M_put_node(__p);
  }

protected:
  size_type _M_node_count;
  _Compare _M_key_compare;

  _Link_type& _M_root() const
    { return (_Link_type&) _M_header->_M_parent; }
  _Link_type& _M_leftmost() const
    { return (_Link_type&) _M_header->_M_left; }
  _Link_type& _M_rightmost() const
    { return (_Link_type&) _M_header->_M_right; }

  static _Link_type& _S_left(_Link_type __x)
    { return (_Link_type&)(__x->_M_left); }
  static _Link_type& _S_right(_Link_type __x)
    { return (_Link_type&)(__x->_M_right); }
  static _Link_type& _S_parent(_Link_type __x)
    { return (_Link_type&)(__x->_M_parent); }
  static reference _S_value(_Link_type __x)
    { return __x->_M_value_field; }
  static const _Key& _S_key(_Link_type __x)
    { return _KeyOfValue()(_S_value(__x)); }
  static _Color_type& _S_color(_Link_type __x)
    { return (_Color_type&)(__x->_M_color); }

  static _Link_type& _S_left(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_left); }
  static _Link_type& _S_right(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_right); }
  static _Link_type& _S_parent(_Base_ptr __x)
    { return (_Link_type&)(__x->_M_parent); }
  static reference _S_value(_Base_ptr __x)
    { return ((_Link_type)__x)->_M_value_field; }
  static const _Key& _S_key(_Base_ptr __x)
    { return _KeyOfValue()(_S_value(_Link_type(__x)));}
  static _Color_type& _S_color(_Base_ptr __x)
    { return (_Color_type&)(_Link_type(__x)->_M_color); }

  static _Link_type _S_minimum(_Link_type __x)
    { return (_Link_type) _Rb_tree_node_base::_S_minimum(__x); }

  static _Link_type _S_maximum(_Link_type __x)
    { return (_Link_type) _Rb_tree_node_base::_S_maximum(__x); }

public:
  typedef _Rb_tree_iterator<value_type, reference, pointer> iterator;
  typedef _Rb_tree_iterator<value_type, const_reference, const_pointer>
          const_iterator;


  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
# 663 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
private:
  iterator _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
  _Link_type _M_copy(_Link_type __x, _Link_type __p);
  void _M_erase(_Link_type __x);

public:

  _Rb_tree()
    : _Base(allocator_type()), _M_node_count(0), _M_key_compare()
    { _M_empty_initialize(); }

  _Rb_tree(const _Compare& __comp)
    : _Base(allocator_type()), _M_node_count(0), _M_key_compare(__comp)
    { _M_empty_initialize(); }

  _Rb_tree(const _Compare& __comp, const allocator_type& __a)
    : _Base(__a), _M_node_count(0), _M_key_compare(__comp)
    { _M_empty_initialize(); }

  _Rb_tree(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
    : _Base(__x.get_allocator()),
      _M_node_count(0), _M_key_compare(__x._M_key_compare)
  {
    if (__x._M_root() == 0)
      _M_empty_initialize();
    else {
      _S_color(_M_header) = _S_rb_tree_red;
      _M_root() = _M_copy(__x._M_root(), _M_header);
      _M_leftmost() = _S_minimum(_M_root());
      _M_rightmost() = _S_maximum(_M_root());
    }
    _M_node_count = __x._M_node_count;
  }
  ~_Rb_tree() { clear(); }
  _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>&
  operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x);

private:
  void _M_empty_initialize() {
    _S_color(_M_header) = _S_rb_tree_red;

    _M_root() = 0;
    _M_leftmost() = _M_header;
    _M_rightmost() = _M_header;
  }

public:

  _Compare key_comp() const { return _M_key_compare; }
  iterator begin() { return _M_leftmost(); }
  const_iterator begin() const { return _M_leftmost(); }
  iterator end() { return _M_header; }
  const_iterator end() const { return _M_header; }
  reverse_iterator rbegin() { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(end());
  }
  reverse_iterator rend() { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(begin());
  }
  bool empty() const { return _M_node_count == 0; }
  size_type size() const { return _M_node_count; }
  size_type max_size() const { return size_type(-1); }

  void swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __t) {
    std::swap(_M_header, __t._M_header);
    std::swap(_M_node_count, __t._M_node_count);
    std::swap(_M_key_compare, __t._M_key_compare);
  }

public:

  pair<iterator,bool> insert_unique(const value_type& __x);
  iterator insert_equal(const value_type& __x);

  iterator insert_unique(iterator __position, const value_type& __x);
  iterator insert_equal(iterator __position, const value_type& __x);


  template <class _InputIterator>
  void insert_unique(_InputIterator __first, _InputIterator __last);
  template <class _InputIterator>
  void insert_equal(_InputIterator __first, _InputIterator __last);







  void erase(iterator __position);
  size_type erase(const key_type& __x);
  void erase(iterator __first, iterator __last);
  void erase(const key_type* __first, const key_type* __last);
  void clear() {
    if (_M_node_count != 0) {
      _M_erase(_M_root());
      _M_leftmost() = _M_header;
      _M_root() = 0;
      _M_rightmost() = _M_header;
      _M_node_count = 0;
    }
  }

public:

  iterator find(const key_type& __x);
  const_iterator find(const key_type& __x) const;
  size_type count(const key_type& __x) const;
  iterator lower_bound(const key_type& __x);
  const_iterator lower_bound(const key_type& __x) const;
  iterator upper_bound(const key_type& __x);
  const_iterator upper_bound(const key_type& __x) const;
  pair<iterator,iterator> equal_range(const key_type& __x);
  pair<const_iterator, const_iterator> equal_range(const key_type& __x) const;

public:

  bool __rb_verify() const;
};

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator==(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  return __x.size() == __y.size() &&
         equal(__x.begin(), __x.end(), __y.begin());
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator<(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
          const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(),
                                 __y.begin(), __y.end());
}



template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator!=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator>(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
          const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator<=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline bool
operator>=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
           const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}


template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline void
swap(_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x,
     _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __y)
{
  __x.swap(__y);
}




template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>&
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::operator=(const _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>& __x)
{
  if (this != &__x) {

    clear();
    _M_node_count = 0;
    _M_key_compare = __x._M_key_compare;
    if (__x._M_root() == 0) {
      _M_root() = 0;
      _M_leftmost() = _M_header;
      _M_rightmost() = _M_header;
    }
    else {
      _M_root() = _M_copy(__x._M_root(), _M_header);
      _M_leftmost() = _S_minimum(_M_root());
      _M_rightmost() = _S_maximum(_M_root());
      _M_node_count = __x._M_node_count;
    }
  }
  return *this;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::_M_insert(_Base_ptr __x_, _Base_ptr __y_, const _Value& __v)
{
  _Link_type __x = (_Link_type) __x_;
  _Link_type __y = (_Link_type) __y_;
  _Link_type __z;

  if (__y == _M_header || __x != 0 ||
      _M_key_compare(_KeyOfValue()(__v), _S_key(__y))) {
    __z = _M_create_node(__v);
    _S_left(__y) = __z;

    if (__y == _M_header) {
      _M_root() = __z;
      _M_rightmost() = __z;
    }
    else if (__y == _M_leftmost())
      _M_leftmost() = __z;
  }
  else {
    __z = _M_create_node(__v);
    _S_right(__y) = __z;
    if (__y == _M_rightmost())
      _M_rightmost() = __z;
  }
  _S_parent(__z) = __y;
  _S_left(__z) = 0;
  _S_right(__z) = 0;
  _Rb_tree_rebalance(__z, _M_header->_M_parent);
  ++_M_node_count;
  return iterator(__z);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_equal(const _Value& __v)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();
  while (__x != 0) {
    __y = __x;
    __x = _M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
            _S_left(__x) : _S_right(__x);
  }
  return _M_insert(__x, __y, __v);
}


template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
     bool>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::insert_unique(const _Value& __v)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();
  bool __comp = true;
  while (__x != 0) {
    __y = __x;
    __comp = _M_key_compare(_KeyOfValue()(__v), _S_key(__x));
    __x = __comp ? _S_left(__x) : _S_right(__x);
  }
  iterator __j = iterator(__y);
  if (__comp)
    if (__j == begin())
      return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
    else
      --__j;
  if (_M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
    return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
  return pair<iterator,bool>(__j, false);
}


template <class _Key, class _Val, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>
  ::insert_unique(iterator __position, const _Val& __v)
{
  if (__position._M_node == _M_header->_M_left) {
    if (size() > 0 &&
       _M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
      return _M_insert(__position._M_node, __position._M_node, __v);

    else
      return insert_unique(__v).first;
  } else if (__position._M_node == _M_header) {
    if (_M_key_compare(_S_key(_M_rightmost()), _KeyOfValue()(__v)))
      return _M_insert(0, _M_rightmost(), __v);
    else
      return insert_unique(__v).first;
  } else {
    iterator __before = __position;
    --__before;
    if (_M_key_compare(_S_key(__before._M_node), _KeyOfValue()(__v))
        && _M_key_compare(_KeyOfValue()(__v), _S_key(__position._M_node))) {
      if (_S_right(__before._M_node) == 0)
        return _M_insert(0, __before._M_node, __v);
      else
        return _M_insert(__position._M_node, __position._M_node, __v);

    } else
      return insert_unique(__v).first;
  }
}

template <class _Key, class _Val, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>
  ::insert_equal(iterator __position, const _Val& __v)
{
  if (__position._M_node == _M_header->_M_left) {
    if (size() > 0 &&
        !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v)))
      return _M_insert(__position._M_node, __position._M_node, __v);

    else
      return insert_equal(__v);
  } else if (__position._M_node == _M_header) {
    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(_M_rightmost())))
      return _M_insert(0, _M_rightmost(), __v);
    else
      return insert_equal(__v);
  } else {
    iterator __before = __position;
    --__before;
    if (!_M_key_compare(_KeyOfValue()(__v), _S_key(__before._M_node))
        && !_M_key_compare(_S_key(__position._M_node), _KeyOfValue()(__v))) {
      if (_S_right(__before._M_node) == 0)
        return _M_insert(0, __before._M_node, __v);
      else
        return _M_insert(__position._M_node, __position._M_node, __v);

    } else
      return insert_equal(__v);
  }
}



template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
  template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
  ::insert_equal(_II __first, _II __last)
{
  for ( ; __first != __last; ++__first)
    insert_equal(*__first);
}

template <class _Key, class _Val, class _KoV, class _Cmp, class _Alloc>
  template<class _II>
void _Rb_tree<_Key,_Val,_KoV,_Cmp,_Alloc>
  ::insert_unique(_II __first, _II __last) {
  for ( ; __first != __last; ++__first)
    insert_unique(*__first);
}
# 1082 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 3
template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(iterator __position)
{
  _Link_type __y =
    (_Link_type) _Rb_tree_rebalance_for_erase(__position._M_node,
                                              _M_header->_M_parent,
                                              _M_header->_M_left,
                                              _M_header->_M_right);
  destroy_node(__y);
  --_M_node_count;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::erase(const _Key& __x)
{
  pair<iterator,iterator> __p = equal_range(__x);
  size_type __n = 0;
  distance(__p.first, __p.second, __n);
  erase(__p.first, __p.second);
  return __n;
}

template <class _Key, class _Val, class _KoV, class _Compare, class _Alloc>
typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
_Rb_tree<_Key,_Val,_KoV,_Compare,_Alloc>
  ::_M_copy(_Link_type __x, _Link_type __p)
{

  _Link_type __top = _M_clone_node(__x);
  __top->_M_parent = __p;

  try {
    if (__x->_M_right)
      __top->_M_right = _M_copy(_S_right(__x), __top);
    __p = __top;
    __x = _S_left(__x);

    while (__x != 0) {
      _Link_type __y = _M_clone_node(__x);
      __p->_M_left = __y;
      __y->_M_parent = __p;
      if (__x->_M_right)
        __y->_M_right = _M_copy(_S_right(__x), __y);
      __p = __y;
      __x = _S_left(__x);
    }
  }
  catch(...) { _M_erase(__top); throw; };

  return __top;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::_M_erase(_Link_type __x)
{

  while (__x != 0) {
    _M_erase(_S_right(__x));
    _Link_type __y = _S_left(__x);
    destroy_node(__x);
    __x = __y;
  }
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(iterator __first, iterator __last)
{
  if (__first == begin() && __last == end())
    clear();
  else
    while (__first != __last) erase(__first++);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
void _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::erase(const _Key* __first, const _Key* __last)
{
  while (__first != __last) erase(*__first++);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  iterator __j = iterator(__y);
  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
     end() : __j;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::find(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0) {
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);
  }
  const_iterator __j = const_iterator(__y);
  return (__j == end() || _M_key_compare(__k, _S_key(__j._M_node))) ?
    end() : __j;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::size_type
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::count(const _Key& __k) const
{
  pair<const_iterator, const_iterator> __p = equal_range(__k);
  size_type __n = 0;
  distance(__p.first, __p.second, __n);
  return __n;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::lower_bound(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  return iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::lower_bound(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

  while (__x != 0)
    if (!_M_key_compare(_S_key(__x), __k))
      __y = __x, __x = _S_left(__x);
    else
      __x = _S_right(__x);

  return const_iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::upper_bound(const _Key& __k)
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

   while (__x != 0)
     if (_M_key_compare(__k, _S_key(__x)))
       __y = __x, __x = _S_left(__x);
     else
       __x = _S_right(__x);

   return iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::const_iterator
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::upper_bound(const _Key& __k) const
{
  _Link_type __y = _M_header;
  _Link_type __x = _M_root();

   while (__x != 0)
     if (_M_key_compare(__k, _S_key(__x)))
       __y = __x, __x = _S_left(__x);
     else
       __x = _S_right(__x);

   return const_iterator(__y);
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator,
     typename _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::iterator>
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>
  ::equal_range(const _Key& __k)
{
  return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k));
}

template <class _Key, class _Value, class _KoV, class _Compare, class _Alloc>
inline
pair<typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator,
     typename _Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>::const_iterator>
_Rb_tree<_Key, _Value, _KoV, _Compare, _Alloc>
  ::equal_range(const _Key& __k) const
{
  return pair<const_iterator,const_iterator>(lower_bound(__k),
                                             upper_bound(__k));
}

inline int
__black_count(_Rb_tree_node_base* __node, _Rb_tree_node_base* __root)
{
  if (__node == 0)
    return 0;
  int __sum = 0;
  do {
    if (__node->_M_color == _S_rb_tree_black)
      ++__sum;
    if (__node == __root)
      break;
    __node = __node->_M_parent;
  } while (1);
  return __sum;
}

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc>
bool _Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
{
  if (_M_node_count == 0 || begin() == end())
    return _M_node_count == 0 && begin() == end() &&
      _M_header->_M_left == _M_header && _M_header->_M_right == _M_header;

  int __len = __black_count(_M_leftmost(), _M_root());
  for (const_iterator __it = begin(); __it != end(); ++__it) {
    _Link_type __x = (_Link_type) __it._M_node;
    _Link_type __L = _S_left(__x);
    _Link_type __R = _S_right(__x);

    if (__x->_M_color == _S_rb_tree_red)
      if ((__L && __L->_M_color == _S_rb_tree_red) ||
          (__R && __R->_M_color == _S_rb_tree_red))
        return false;

    if (__L && _M_key_compare(_S_key(__x), _S_key(__L)))
      return false;
    if (__R && _M_key_compare(_S_key(__R), _S_key(__x)))
      return false;

    if (!__L && !__R && __black_count(__x, _M_root()) != __len)
      return false;
  }

  if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
    return false;
  if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
    return false;

  return true;
}




template <class _Key, class _Value, class _KeyOfValue, class _Compare,
          class _Alloc = allocator<_Value> >
struct rb_tree : public _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc>
{
  typedef _Rb_tree<_Key, _Value, _KeyOfValue, _Compare, _Alloc> _Base;
  typedef typename _Base::allocator_type allocator_type;

  rb_tree(const _Compare& __comp = _Compare(),
          const allocator_type& __a = allocator_type())
    : _Base(__comp, __a) {}

  ~rb_tree() {}
};





}
# 32 "/opt/gcc3/include/g++-v3/bits/std_map.h" 2 3

# 1 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 2 3

namespace std {






template <class _Key, class _Tp, class _Compare = less<_Key>,
          class _Alloc = allocator<pair<const _Key, _Tp> > >
class map {
public:



  typedef void (* __func_Tp_Assignable)( _Tp ); template <__func_Tp_Assignable _Tp1> struct __dummy_struct__Tp_Assignable { }; static __dummy_struct__Tp_Assignable< _Assignable_concept_specification< _Tp>::_Assignable_requirement_violation> __dummy_ptr__Tp_Assignable;
  typedef bool (* __f__Comparebool_Key_Key_binary_check)( _Compare&, const _Key&, const _Key& ); template <__f__Comparebool_Key_Key_binary_check _Tp1> struct __dummy_struct__Comparebool_Key_Key_binary_check { }; static __dummy_struct__Comparebool_Key_Key_binary_check< _STL_BINARY_FUNCTION_ERROR<_Compare, bool, _Key, _Key>:: __binary_function_requirement_violation> __dummy_ptr__Comparebool_Key_Key_binary_check;



  typedef _Key key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef pair<const _Key, _Tp> value_type;
  typedef _Compare key_compare;

  class value_compare
    : public binary_function<value_type, value_type, bool> {
  friend class map<_Key,_Tp,_Compare,_Alloc>;
  protected :
    _Compare comp;
    value_compare(_Compare __c) : comp(__c) {}
  public:
    bool operator()(const value_type& __x, const value_type& __y) const {
      return comp(__x.first, __y.first);
    }
  };

private:
  typedef _Rb_tree<key_type, value_type,
                   _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  map() : _M_t(_Compare(), allocator_type()) {}
  explicit map(const _Compare& __comp,
               const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) {}


  template <class _InputIterator>
  map(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_unique(__first, __last); }

  template <class _InputIterator>
  map(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
      const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
# 127 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 3
  map(const map<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
  map<_Key,_Tp,_Compare,_Alloc>&
  operator=(const map<_Key, _Tp, _Compare, _Alloc>& __x)
  {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() { return _M_t.begin(); }
  const_iterator begin() const { return _M_t.begin(); }
  iterator end() { return _M_t.end(); }
  const_iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() { return _M_t.rbegin(); }
  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() { return _M_t.rend(); }
  const_reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  _Tp& operator[](const key_type& __k) {
    iterator __i = lower_bound(__k);

    if (__i == end() || key_comp()(__k, (*__i).first))
      __i = insert(__i, value_type(__k, _Tp()));
    return (*__i).second;
  }
  void swap(map<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }



  pair<iterator,bool> insert(const value_type& __x)
    { return _M_t.insert_unique(__x); }
  iterator insert(iterator position, const value_type& __x)
    { return _M_t.insert_unique(position, __x); }

  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_unique(__first, __last);
  }
# 181 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 3
  void erase(iterator __position) { _M_t.erase(__position); }
  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
  void erase(iterator __first, iterator __last)
    { _M_t.erase(__first, __last); }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) { return _M_t.find(__x); }
  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const {
    return _M_t.find(__x) == _M_t.end() ? 0 : 1;
  }
  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
  const_iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
  const_iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }

  pair<iterator,iterator> equal_range(const key_type& __x) {
    return _M_t.equal_range(__x);
  }
  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }


  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator== (const map<_K1, _T1, _C1, _A1>&,
                          const map<_K1, _T1, _C1, _A1>&);
  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator< (const map<_K1, _T1, _C1, _A1>&,
                         const map<_K1, _T1, _C1, _A1>&);






};

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                      const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}



template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator!=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                      const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>=(const map<_Key,_Tp,_Compare,_Alloc>& __x,
                       const map<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline void swap(map<_Key,_Tp,_Compare,_Alloc>& __x,
                 map<_Key,_Tp,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}
# 276 "/opt/gcc3/include/g++-v3/bits/stl_map.h" 3
}
# 34 "/opt/gcc3/include/g++-v3/bits/std_map.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 2 3

namespace std {
# 45 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 3
template <class _Key, class _Tp,
          class _Compare = less<_Key>,
          class _Alloc = allocator<pair<const _Key, _Tp> > >
class multimap;

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y);

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y);

template <class _Key, class _Tp, class _Compare, class _Alloc>
class multimap {


  typedef void (* __func_Tp_Assignable)( _Tp ); template <__func_Tp_Assignable _Tp1> struct __dummy_struct__Tp_Assignable { }; static __dummy_struct__Tp_Assignable< _Assignable_concept_specification< _Tp>::_Assignable_requirement_violation> __dummy_ptr__Tp_Assignable;
  typedef bool (* __f__Comparebool_Key_Key_binary_check)( _Compare&, const _Key&, const _Key& ); template <__f__Comparebool_Key_Key_binary_check _Tp1> struct __dummy_struct__Comparebool_Key_Key_binary_check { }; static __dummy_struct__Comparebool_Key_Key_binary_check< _STL_BINARY_FUNCTION_ERROR<_Compare, bool, _Key, _Key>:: __binary_function_requirement_violation> __dummy_ptr__Comparebool_Key_Key_binary_check;

public:



  typedef _Key key_type;
  typedef _Tp data_type;
  typedef _Tp mapped_type;
  typedef pair<const _Key, _Tp> value_type;
  typedef _Compare key_compare;

  class value_compare : public binary_function<value_type, value_type, bool> {
  friend class multimap<_Key,_Tp,_Compare,_Alloc>;
  protected:
    _Compare comp;
    value_compare(_Compare __c) : comp(__c) {}
  public:
    bool operator()(const value_type& __x, const value_type& __y) const {
      return comp(__x.first, __y.first);
    }
  };

private:
  typedef _Rb_tree<key_type, value_type,
                  _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  multimap() : _M_t(_Compare(), allocator_type()) { }
  explicit multimap(const _Compare& __comp,
                    const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { }


  template <class _InputIterator>
  multimap(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  template <class _InputIterator>
  multimap(_InputIterator __first, _InputIterator __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
# 139 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 3
  multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { }
  multimap<_Key,_Tp,_Compare,_Alloc>&
  operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() { return _M_t.begin(); }
  const_iterator begin() const { return _M_t.begin(); }
  iterator end() { return _M_t.end(); }
  const_iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() { return _M_t.rbegin(); }
  const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() { return _M_t.rend(); }
  const_reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }



  iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
  iterator insert(iterator __position, const value_type& __x) {
    return _M_t.insert_equal(__position, __x);
  }

  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_equal(__first, __last);
  }
# 184 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 3
  void erase(iterator __position) { _M_t.erase(__position); }
  size_type erase(const key_type& __x) { return _M_t.erase(__x); }
  void erase(iterator __first, iterator __last)
    { _M_t.erase(__first, __last); }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) { return _M_t.find(__x); }
  const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const { return _M_t.count(__x); }
  iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
  const_iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
  const_iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }
   pair<iterator,iterator> equal_range(const key_type& __x) {
    return _M_t.equal_range(__x);
  }
  pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }


  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&,
                          const multimap<_K1, _T1, _C1, _A1>&);
  template <class _K1, class _T1, class _C1, class _A1>
  friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&,
                         const multimap<_K1, _T1, _C1, _A1>&);






};

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}



template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                      const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                       const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Tp, class _Compare, class _Alloc>
inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
                 multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}
# 276 "/opt/gcc3/include/g++-v3/bits/stl_multimap.h" 3
}
# 35 "/opt/gcc3/include/g++-v3/bits/std_map.h" 2 3
# 3 "/opt/gcc3/include/g++-v3/map" 2 3
# 134 "../include/CORBA.h" 2
# 1 "/opt/gcc3/include/g++-v3/set" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_set.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/bits/std_set.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_tree.h" 1 3
# 32 "/opt/gcc3/include/g++-v3/bits/std_set.h" 2 3

# 1 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 2 3

namespace std {
# 45 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 3
template <class _Key, class _Compare = less<_Key>,
          class _Alloc = allocator<_Key> >
class set;

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const set<_Key,_Compare,_Alloc>& __x,
                       const set<_Key,_Compare,_Alloc>& __y);

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const set<_Key,_Compare,_Alloc>& __x,
                      const set<_Key,_Compare,_Alloc>& __y);


template <class _Key, class _Compare, class _Alloc>
class set {


  typedef void (* __func_Key_Assignable)( _Key ); template <__func_Key_Assignable _Tp1> struct __dummy_struct__Key_Assignable { }; static __dummy_struct__Key_Assignable< _Assignable_concept_specification< _Key>::_Assignable_requirement_violation> __dummy_ptr__Key_Assignable;
  typedef bool (* __f__Comparebool_Key_Key_binary_check)( _Compare&, const _Key&, const _Key& ); template <__f__Comparebool_Key_Key_binary_check _Tp1> struct __dummy_struct__Comparebool_Key_Key_binary_check { }; static __dummy_struct__Comparebool_Key_Key_binary_check< _STL_BINARY_FUNCTION_ERROR<_Compare, bool, _Key, _Key>:: __binary_function_requirement_violation> __dummy_ptr__Comparebool_Key_Key_binary_check;

public:


  typedef _Key key_type;
  typedef _Key value_type;
  typedef _Compare key_compare;
  typedef _Compare value_compare;
private:
  typedef _Rb_tree<key_type, value_type,
                  _Identity<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::const_pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::const_reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::const_iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  set() : _M_t(_Compare(), allocator_type()) {}
  explicit set(const _Compare& __comp,
               const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) {}


  template <class _InputIterator>
  set(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_unique(__first, __last); }

  template <class _InputIterator>
  set(_InputIterator __first, _InputIterator __last, const _Compare& __comp,
      const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_unique(__first, __last); }
# 125 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 3
  set(const set<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
  set<_Key,_Compare,_Alloc>& operator=(const set<_Key, _Compare, _Alloc>& __x)
  {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return _M_t.key_comp(); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() const { return _M_t.begin(); }
  iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  void swap(set<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }


  pair<iterator,bool> insert(const value_type& __x) {
    pair<typename _Rep_type::iterator, bool> __p = _M_t.insert_unique(__x);
    return pair<iterator, bool>(__p.first, __p.second);
  }
  iterator insert(iterator __position, const value_type& __x) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    return _M_t.insert_unique((_Rep_iterator&)__position, __x);
  }

  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_unique(__first, __last);
  }
# 169 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 3
  void erase(iterator __position) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__position);
  }
  size_type erase(const key_type& __x) {
    return _M_t.erase(__x);
  }
  void erase(iterator __first, iterator __last) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
  }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const {
    return _M_t.find(__x) == _M_t.end() ? 0 : 1;
  }
  iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }
  pair<iterator,iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }


  template <class _K1, class _C1, class _A1>
  friend bool operator== (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);
  template <class _K1, class _C1, class _A1>
  friend bool operator< (const set<_K1,_C1,_A1>&, const set<_K1,_C1,_A1>&);






};

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const set<_Key,_Compare,_Alloc>& __x,
                       const set<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const set<_Key,_Compare,_Alloc>& __x,
                      const set<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}



template <class _Key, class _Compare, class _Alloc>
inline bool operator!=(const set<_Key,_Compare,_Alloc>& __x,
                       const set<_Key,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>(const set<_Key,_Compare,_Alloc>& __x,
                      const set<_Key,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<=(const set<_Key,_Compare,_Alloc>& __x,
                       const set<_Key,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>=(const set<_Key,_Compare,_Alloc>& __x,
                       const set<_Key,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Compare, class _Alloc>
inline void swap(set<_Key,_Compare,_Alloc>& __x,
                 set<_Key,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}
# 262 "/opt/gcc3/include/g++-v3/bits/stl_set.h" 3
}
# 34 "/opt/gcc3/include/g++-v3/bits/std_set.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 2 3

namespace std {
# 45 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 3
template <class _Key, class _Compare = less<_Key>,
          class _Alloc = allocator<_Key> >
class multiset;

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
                       const multiset<_Key,_Compare,_Alloc>& __y);

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
                      const multiset<_Key,_Compare,_Alloc>& __y);

template <class _Key, class _Compare, class _Alloc>
class multiset {


  typedef void (* __func_Key_Assignable)( _Key ); template <__func_Key_Assignable _Tp1> struct __dummy_struct__Key_Assignable { }; static __dummy_struct__Key_Assignable< _Assignable_concept_specification< _Key>::_Assignable_requirement_violation> __dummy_ptr__Key_Assignable;
  typedef bool (* __f__Comparebool_Key_Key_binary_check)( _Compare&, const _Key&, const _Key& ); template <__f__Comparebool_Key_Key_binary_check _Tp1> struct __dummy_struct__Comparebool_Key_Key_binary_check { }; static __dummy_struct__Comparebool_Key_Key_binary_check< _STL_BINARY_FUNCTION_ERROR<_Compare, bool, _Key, _Key>:: __binary_function_requirement_violation> __dummy_ptr__Comparebool_Key_Key_binary_check;

public:



  typedef _Key key_type;
  typedef _Key value_type;
  typedef _Compare key_compare;
  typedef _Compare value_compare;
private:
  typedef _Rb_tree<key_type, value_type,
                  _Identity<value_type>, key_compare, _Alloc> _Rep_type;
  _Rep_type _M_t;
public:
  typedef typename _Rep_type::const_pointer pointer;
  typedef typename _Rep_type::const_pointer const_pointer;
  typedef typename _Rep_type::const_reference reference;
  typedef typename _Rep_type::const_reference const_reference;
  typedef typename _Rep_type::const_iterator iterator;
  typedef typename _Rep_type::const_iterator const_iterator;
  typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
  typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename _Rep_type::size_type size_type;
  typedef typename _Rep_type::difference_type difference_type;
  typedef typename _Rep_type::allocator_type allocator_type;



  multiset() : _M_t(_Compare(), allocator_type()) {}
  explicit multiset(const _Compare& __comp,
                    const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) {}



  template <class _InputIterator>
  multiset(_InputIterator __first, _InputIterator __last)
    : _M_t(_Compare(), allocator_type())
    { _M_t.insert_equal(__first, __last); }

  template <class _InputIterator>
  multiset(_InputIterator __first, _InputIterator __last,
           const _Compare& __comp,
           const allocator_type& __a = allocator_type())
    : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
# 131 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 3
  multiset(const multiset<_Key,_Compare,_Alloc>& __x) : _M_t(__x._M_t) {}
  multiset<_Key,_Compare,_Alloc>&
  operator=(const multiset<_Key,_Compare,_Alloc>& __x) {
    _M_t = __x._M_t;
    return *this;
  }



  key_compare key_comp() const { return _M_t.key_comp(); }
  value_compare value_comp() const { return _M_t.key_comp(); }
  allocator_type get_allocator() const { return _M_t.get_allocator(); }

  iterator begin() const { return _M_t.begin(); }
  iterator end() const { return _M_t.end(); }
  reverse_iterator rbegin() const { return _M_t.rbegin(); }
  reverse_iterator rend() const { return _M_t.rend(); }
  bool empty() const { return _M_t.empty(); }
  size_type size() const { return _M_t.size(); }
  size_type max_size() const { return _M_t.max_size(); }
  void swap(multiset<_Key,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }


  iterator insert(const value_type& __x) {
    return _M_t.insert_equal(__x);
  }
  iterator insert(iterator __position, const value_type& __x) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    return _M_t.insert_equal((_Rep_iterator&)__position, __x);
  }


  template <class _InputIterator>
  void insert(_InputIterator __first, _InputIterator __last) {
    _M_t.insert_equal(__first, __last);
  }
# 175 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 3
  void erase(iterator __position) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__position);
  }
  size_type erase(const key_type& __x) {
    return _M_t.erase(__x);
  }
  void erase(iterator __first, iterator __last) {
    typedef typename _Rep_type::iterator _Rep_iterator;
    _M_t.erase((_Rep_iterator&)__first, (_Rep_iterator&)__last);
  }
  void clear() { _M_t.clear(); }



  iterator find(const key_type& __x) const { return _M_t.find(__x); }
  size_type count(const key_type& __x) const { return _M_t.count(__x); }
  iterator lower_bound(const key_type& __x) const {
    return _M_t.lower_bound(__x);
  }
  iterator upper_bound(const key_type& __x) const {
    return _M_t.upper_bound(__x);
  }
  pair<iterator,iterator> equal_range(const key_type& __x) const {
    return _M_t.equal_range(__x);
  }


  template <class _K1, class _C1, class _A1>
  friend bool operator== (const multiset<_K1,_C1,_A1>&,
                          const multiset<_K1,_C1,_A1>&);
  template <class _K1, class _C1, class _A1>
  friend bool operator< (const multiset<_K1,_C1,_A1>&,
                         const multiset<_K1,_C1,_A1>&);






};

template <class _Key, class _Compare, class _Alloc>
inline bool operator==(const multiset<_Key,_Compare,_Alloc>& __x,
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t == __y._M_t;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<(const multiset<_Key,_Compare,_Alloc>& __x,
                      const multiset<_Key,_Compare,_Alloc>& __y) {
  return __x._M_t < __y._M_t;
}



template <class _Key, class _Compare, class _Alloc>
inline bool operator!=(const multiset<_Key,_Compare,_Alloc>& __x,
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>(const multiset<_Key,_Compare,_Alloc>& __x,
                      const multiset<_Key,_Compare,_Alloc>& __y) {
  return __y < __x;
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator<=(const multiset<_Key,_Compare,_Alloc>& __x,
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Key, class _Compare, class _Alloc>
inline bool operator>=(const multiset<_Key,_Compare,_Alloc>& __x,
                       const multiset<_Key,_Compare,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Key, class _Compare, class _Alloc>
inline void swap(multiset<_Key,_Compare,_Alloc>& __x,
                 multiset<_Key,_Compare,_Alloc>& __y) {
  __x.swap(__y);
}
# 268 "/opt/gcc3/include/g++-v3/bits/stl_multiset.h" 3
}
# 35 "/opt/gcc3/include/g++-v3/bits/std_set.h" 2 3
# 3 "/opt/gcc3/include/g++-v3/set" 2 3
# 135 "../include/CORBA.h" 2
# 1 "/opt/gcc3/include/g++-v3/list" 1 3

# 1 "/opt/gcc3/include/g++-v3/bits/std_list.h" 1 3
# 30 "/opt/gcc3/include/g++-v3/bits/std_list.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/bits/std_list.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 1 3
# 32 "/opt/gcc3/include/g++-v3/bits/std_list.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 1 3
# 33 "/opt/gcc3/include/g++-v3/bits/std_list.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/std_list.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/concept_checks.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 2 3

namespace std {






struct _List_node_base {
  _List_node_base* _M_next;
  _List_node_base* _M_prev;
};

template <class _Tp>
struct _List_node : public _List_node_base {
  _Tp _M_data;
};

struct _List_iterator_base {
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef bidirectional_iterator_tag iterator_category;

  _List_node_base* _M_node;

  _List_iterator_base(_List_node_base* __x) : _M_node(__x) {}
  _List_iterator_base() {}

  void _M_incr() { _M_node = _M_node->_M_next; }
  void _M_decr() { _M_node = _M_node->_M_prev; }

  bool operator==(const _List_iterator_base& __x) const {
    return _M_node == __x._M_node;
  }
  bool operator!=(const _List_iterator_base& __x) const {
    return _M_node != __x._M_node;
  }
};

template<class _Tp, class _Ref, class _Ptr>
struct _List_iterator : public _List_iterator_base {
  typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
  typedef _List_iterator<_Tp,_Ref,_Ptr> _Self;

  typedef _Tp value_type;
  typedef _Ptr pointer;
  typedef _Ref reference;
  typedef _List_node<_Tp> _Node;

  _List_iterator(_Node* __x) : _List_iterator_base(__x) {}
  _List_iterator() {}
  _List_iterator(const iterator& __x) : _List_iterator_base(__x._M_node) {}

  reference operator*() const { return ((_Node*) _M_node)->_M_data; }


  pointer operator->() const { return &(operator*()); }


  _Self& operator++() {
    this->_M_incr();
    return *this;
  }
  _Self operator++(int) {
    _Self __tmp = *this;
    this->_M_incr();
    return __tmp;
  }
  _Self& operator--() {
    this->_M_decr();
    return *this;
  }
  _Self operator--(int) {
    _Self __tmp = *this;
    this->_M_decr();
    return __tmp;
  }
};
# 149 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
template <class _Tp, class _Allocator, bool _IsStatic>
class _List_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return _Node_allocator; }

  _List_alloc_base(const allocator_type& __a) : _Node_allocator(__a) {}

protected:
  _List_node<_Tp>* _M_get_node()
   { return _Node_allocator.allocate(1); }
  void _M_put_node(_List_node<_Tp>* __p)
    { _Node_allocator.deallocate(__p, 1); }

protected:
  typename _Alloc_traits<_List_node<_Tp>, _Allocator>::allocator_type
           _Node_allocator;
  _List_node<_Tp>* _M_node;
};



template <class _Tp, class _Allocator>
class _List_alloc_base<_Tp, _Allocator, true> {
public:
  typedef typename _Alloc_traits<_Tp, _Allocator>::allocator_type
          allocator_type;
  allocator_type get_allocator() const { return allocator_type(); }

  _List_alloc_base(const allocator_type&) {}

protected:
  typedef typename _Alloc_traits<_List_node<_Tp>, _Allocator>::_Alloc_type
          _Alloc_type;
  _List_node<_Tp>* _M_get_node() { return _Alloc_type::allocate(1); }
  void _M_put_node(_List_node<_Tp>* __p) { _Alloc_type::deallocate(__p, 1); }

protected:
  _List_node<_Tp>* _M_node;
};

template <class _Tp, class _Alloc>
class _List_base
  : public _List_alloc_base<_Tp, _Alloc,
                            _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
public:
  typedef _List_alloc_base<_Tp, _Alloc,
                           _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;

  _List_base(const allocator_type& __a) : _Base(__a) {
    _M_node = _M_get_node();
    _M_node->_M_next = _M_node;
    _M_node->_M_prev = _M_node;
  }
  ~_List_base() {
    clear();
    _M_put_node(_M_node);
  }

  void clear();
};
# 247 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
template <class _Tp, class _Alloc>
void
_List_base<_Tp,_Alloc>::clear()
{
  _List_node<_Tp>* __cur = (_List_node<_Tp>*) _M_node->_M_next;
  while (__cur != _M_node) {
    _List_node<_Tp>* __tmp = __cur;
    __cur = (_List_node<_Tp>*) __cur->_M_next;
    _Destroy(&__tmp->_M_data);
    _M_put_node(__tmp);
  }
  _M_node->_M_next = _M_node;
  _M_node->_M_prev = _M_node;
}

template <class _Tp, class _Alloc = allocator<_Tp> >
class list : protected _List_base<_Tp, _Alloc> {


  typedef void (* __func_Tp_Assignable)( _Tp ); template <__func_Tp_Assignable _Tp1> struct __dummy_struct__Tp_Assignable { }; static __dummy_struct__Tp_Assignable< _Assignable_concept_specification< _Tp>::_Assignable_requirement_violation> __dummy_ptr__Tp_Assignable;

  typedef _List_base<_Tp, _Alloc> _Base;
protected:
  typedef void* _Void_pointer;

public:
  typedef _Tp value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef _List_node<_Tp> _Node;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }

public:
  typedef _List_iterator<_Tp,_Tp&,_Tp*> iterator;
  typedef _List_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;


  typedef reverse_iterator<const_iterator> const_reverse_iterator;
  typedef reverse_iterator<iterator> reverse_iterator;
# 301 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
protected:

  using _Base::_M_node;
  using _Base::_M_put_node;
  using _Base::_M_get_node;


protected:
  _Node* _M_create_node(const _Tp& __x)
  {
    _Node* __p = _M_get_node();
    try {
      _Construct(&__p->_M_data, __x);
    }
    catch(...) { _M_put_node(__p); throw; };
    return __p;
  }

  _Node* _M_create_node()
  {
    _Node* __p = _M_get_node();
    try {
      _Construct(&__p->_M_data);
    }
    catch(...) { _M_put_node(__p); throw; };
    return __p;
  }

public:
  explicit list(const allocator_type& __a = allocator_type()) : _Base(__a) {}

  iterator begin() { return (_Node*)(_M_node->_M_next); }
  const_iterator begin() const { return (_Node*)(_M_node->_M_next); }

  iterator end() { return _M_node; }
  const_iterator end() const { return _M_node; }

  reverse_iterator rbegin()
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const
    { return const_reverse_iterator(end()); }

  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }

  bool empty() const { return _M_node->_M_next == _M_node; }
  size_type size() const {
    size_type __result = 0;
    distance(begin(), end(), __result);
    return __result;
  }
  size_type max_size() const { return size_type(-1); }

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(--end()); }
  const_reference back() const { return *(--end()); }

  void swap(list<_Tp, _Alloc>& __x) { std::swap(_M_node, __x._M_node); }

  iterator insert(iterator __position, const _Tp& __x) {
    _Node* __tmp = _M_create_node(__x);
    __tmp->_M_next = __position._M_node;
    __tmp->_M_prev = __position._M_node->_M_prev;
    __position._M_node->_M_prev->_M_next = __tmp;
    __position._M_node->_M_prev = __tmp;
    return __tmp;
  }
  iterator insert(iterator __position) { return insert(__position, _Tp()); }



  template<class _Integer>
  void _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
                          __true_type) {
    _M_fill_insert(__pos, (size_type) __n, (_Tp) __x);
  }

  template <class _InputIterator>
  void _M_insert_dispatch(iterator __pos,
                          _InputIterator __first, _InputIterator __last,
                          __false_type);

  template <class _InputIterator>
  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_insert_dispatch(__pos, __first, __last, _Integral());
  }






  void insert(iterator __pos, size_type __n, const _Tp& __x)
    { _M_fill_insert(__pos, __n, __x); }
  void _M_fill_insert(iterator __pos, size_type __n, const _Tp& __x);

  void push_front(const _Tp& __x) { insert(begin(), __x); }
  void push_front() {insert(begin());}
  void push_back(const _Tp& __x) { insert(end(), __x); }
  void push_back() {insert(end());}

  iterator erase(iterator __position) {
    _List_node_base* __next_node = __position._M_node->_M_next;
    _List_node_base* __prev_node = __position._M_node->_M_prev;
    _Node* __n = (_Node*) __position._M_node;
    __prev_node->_M_next = __next_node;
    __next_node->_M_prev = __prev_node;
    _Destroy(&__n->_M_data);
    _M_put_node(__n);
    return iterator((_Node*) __next_node);
  }
  iterator erase(iterator __first, iterator __last);
  void clear() { _Base::clear(); }

  void resize(size_type __new_size, const _Tp& __x);
  void resize(size_type __new_size) { this->resize(__new_size, _Tp()); }

  void pop_front() { erase(begin()); }
  void pop_back() {
    iterator __tmp = end();
    erase(--__tmp);
  }
  list(size_type __n, const _Tp& __value,
       const allocator_type& __a = allocator_type())
    : _Base(__a)
    { insert(begin(), __n, __value); }
  explicit list(size_type __n)
    : _Base(allocator_type())
    { insert(begin(), __n, _Tp()); }





  template <class _InputIterator>
  list(_InputIterator __first, _InputIterator __last,
       const allocator_type& __a = allocator_type())
    : _Base(__a)
    { insert(begin(), __first, __last); }
# 457 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
  list(const list<_Tp, _Alloc>& __x) : _Base(__x.get_allocator())
    { insert(begin(), __x.begin(), __x.end()); }

  ~list() { }

  list<_Tp, _Alloc>& operator=(const list<_Tp, _Alloc>& __x);

public:





  void assign(size_type __n, const _Tp& __val) { _M_fill_assign(__n, __val); }

  void _M_fill_assign(size_type __n, const _Tp& __val);



  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
    _M_assign_dispatch(__first, __last, _Integral());
  }

  template <class _Integer>
  void _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
    { _M_fill_assign((size_type) __n, (_Tp) __val); }

  template <class _InputIterator>
  void _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
                          __false_type);



protected:
  void transfer(iterator __position, iterator __first, iterator __last) {
    if (__position != __last) {

      __last._M_node->_M_prev->_M_next = __position._M_node;
      __first._M_node->_M_prev->_M_next = __last._M_node;
      __position._M_node->_M_prev->_M_next = __first._M_node;


      _List_node_base* __tmp = __position._M_node->_M_prev;
      __position._M_node->_M_prev = __last._M_node->_M_prev;
      __last._M_node->_M_prev = __first._M_node->_M_prev;
      __first._M_node->_M_prev = __tmp;
    }
  }

public:
  void splice(iterator __position, list& __x) {
    if (!__x.empty())
      this->transfer(__position, __x.begin(), __x.end());
  }
  void splice(iterator __position, list&, iterator __i) {
    iterator __j = __i;
    ++__j;
    if (__position == __i || __position == __j) return;
    this->transfer(__position, __i, __j);
  }
  void splice(iterator __position, list&, iterator __first, iterator __last) {
    if (__first != __last)
      this->transfer(__position, __first, __last);
  }
  void remove(const _Tp& __value);
  void unique();
  void merge(list& __x);
  void reverse();
  void sort();


  template <class _Predicate> void remove_if(_Predicate);
  template <class _BinaryPredicate> void unique(_BinaryPredicate);
  template <class _StrictWeakOrdering> void merge(list&, _StrictWeakOrdering);
  template <class _StrictWeakOrdering> void sort(_StrictWeakOrdering);

};

template <class _Tp, class _Alloc>
inline bool
operator==(const list<_Tp,_Alloc>& __x, const list<_Tp,_Alloc>& __y)
{
  typedef typename list<_Tp,_Alloc>::const_iterator const_iterator;
  const_iterator __end1 = __x.end();
  const_iterator __end2 = __y.end();

  const_iterator __i1 = __x.begin();
  const_iterator __i2 = __y.begin();
  while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) {
    ++__i1;
    ++__i2;
  }
  return __i1 == __end1 && __i2 == __end2;
}

template <class _Tp, class _Alloc>
inline bool operator<(const list<_Tp,_Alloc>& __x,
                      const list<_Tp,_Alloc>& __y)
{
  return lexicographical_compare(__x.begin(), __x.end(),
                                 __y.begin(), __y.end());
}



template <class _Tp, class _Alloc>
inline bool operator!=(const list<_Tp,_Alloc>& __x,
                       const list<_Tp,_Alloc>& __y) {
  return !(__x == __y);
}

template <class _Tp, class _Alloc>
inline bool operator>(const list<_Tp,_Alloc>& __x,
                      const list<_Tp,_Alloc>& __y) {
  return __y < __x;
}

template <class _Tp, class _Alloc>
inline bool operator<=(const list<_Tp,_Alloc>& __x,
                       const list<_Tp,_Alloc>& __y) {
  return !(__y < __x);
}

template <class _Tp, class _Alloc>
inline bool operator>=(const list<_Tp,_Alloc>& __x,
                       const list<_Tp,_Alloc>& __y) {
  return !(__x < __y);
}

template <class _Tp, class _Alloc>
inline void
swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
{
  __x.swap(__y);
}





template <class _Tp, class _Alloc> template <class _InputIter>
void
list<_Tp, _Alloc>::_M_insert_dispatch(iterator __position,
                                      _InputIter __first, _InputIter __last,
                                      __false_type)
{
  for ( ; __first != __last; ++__first)
    insert(__position, *__first);
}
# 631 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
template <class _Tp, class _Alloc>
void
list<_Tp, _Alloc>::_M_fill_insert(iterator __position,
                                  size_type __n, const _Tp& __x)
{
  for ( ; __n > 0; --__n)
    insert(__position, __x);
}

template <class _Tp, class _Alloc>
typename list<_Tp,_Alloc>::iterator list<_Tp, _Alloc>::erase(iterator __first,
                                                             iterator __last)
{
  while (__first != __last)
    erase(__first++);
  return __last;
}

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::resize(size_type __new_size, const _Tp& __x)
{
  iterator __i = begin();
  size_type __len = 0;
  for ( ; __i != end() && __len < __new_size; ++__i, ++__len)
    ;
  if (__len == __new_size)
    erase(__i, end());
  else
    insert(end(), __new_size - __len, __x);
}

template <class _Tp, class _Alloc>
list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(const list<_Tp, _Alloc>& __x)
{
  if (this != &__x) {
    iterator __first1 = begin();
    iterator __last1 = end();
    const_iterator __first2 = __x.begin();
    const_iterator __last2 = __x.end();
    while (__first1 != __last1 && __first2 != __last2)
      *__first1++ = *__first2++;
    if (__first2 == __last2)
      erase(__first1, __last1);
    else
      insert(__last1, __first2, __last2);
  }
  return *this;
}

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val) {
  iterator __i = begin();
  for ( ; __i != end() && __n > 0; ++__i, --__n)
    *__i = __val;
  if (__n > 0)
    insert(end(), __n, __val);
  else
    erase(__i, end());
}



template <class _Tp, class _Alloc> template <class _InputIter>
void
list<_Tp, _Alloc>::_M_assign_dispatch(_InputIter __first2, _InputIter __last2,
                                      __false_type)
{
  iterator __first1 = begin();
  iterator __last1 = end();
  for ( ; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
    *__first1 = *__first2;
  if (__first2 == __last2)
    erase(__first1, __last1);
  else
    insert(__last1, __first2, __last2);
}



template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::remove(const _Tp& __value)
{
  iterator __first = begin();
  iterator __last = end();
  while (__first != __last) {
    iterator __next = __first;
    ++__next;
    if (*__first == __value) erase(__first);
    __first = __next;
  }
}

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::unique()
{
  iterator __first = begin();
  iterator __last = end();
  if (__first == __last) return;
  iterator __next = __first;
  while (++__next != __last) {
    if (*__first == *__next)
      erase(__next);
    else
      __first = __next;
    __next = __first;
  }
}

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x)
{
  iterator __first1 = begin();
  iterator __last1 = end();
  iterator __first2 = __x.begin();
  iterator __last2 = __x.end();
  while (__first1 != __last1 && __first2 != __last2)
    if (*__first2 < *__first1) {
      iterator __next = __first2;
      transfer(__first1, __first2, ++__next);
      __first2 = __next;
    }
    else
      ++__first1;
  if (__first2 != __last2) transfer(__last1, __first2, __last2);
}

inline void __List_base_reverse(_List_node_base* __p)
{
  _List_node_base* __tmp = __p;
  do {
    std::swap(__tmp->_M_next, __tmp->_M_prev);
    __tmp = __tmp->_M_prev;
  } while (__tmp != __p);
}

template <class _Tp, class _Alloc>
inline void list<_Tp, _Alloc>::reverse()
{
  __List_base_reverse(this->_M_node);
}

template <class _Tp, class _Alloc>
void list<_Tp, _Alloc>::sort()
{

  if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
    list<_Tp, _Alloc> __carry;
    list<_Tp, _Alloc> __counter[64];
    int __fill = 0;
    while (!empty()) {
      __carry.splice(__carry.begin(), *this, begin());
      int __i = 0;
      while(__i < __fill && !__counter[__i].empty()) {
        __counter[__i].merge(__carry);
        __carry.swap(__counter[__i++]);
      }
      __carry.swap(__counter[__i]);
      if (__i == __fill) ++__fill;
    }

    for (int __i = 1; __i < __fill; ++__i)
      __counter[__i].merge(__counter[__i-1]);
    swap(__counter[__fill-1]);
  }
}



template <class _Tp, class _Alloc> template <class _Predicate>
void list<_Tp, _Alloc>::remove_if(_Predicate __pred)
{
  iterator __first = begin();
  iterator __last = end();
  while (__first != __last) {
    iterator __next = __first;
    ++__next;
    if (__pred(*__first)) erase(__first);
    __first = __next;
  }
}

template <class _Tp, class _Alloc> template <class _BinaryPredicate>
void list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
{
  iterator __first = begin();
  iterator __last = end();
  if (__first == __last) return;
  iterator __next = __first;
  while (++__next != __last) {
    if (__binary_pred(*__first, *__next))
      erase(__next);
    else
      __first = __next;
    __next = __first;
  }
}

template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>
void list<_Tp, _Alloc>::merge(list<_Tp, _Alloc>& __x,
                              _StrictWeakOrdering __comp)
{
  iterator __first1 = begin();
  iterator __last1 = end();
  iterator __first2 = __x.begin();
  iterator __last2 = __x.end();
  while (__first1 != __last1 && __first2 != __last2)
    if (__comp(*__first2, *__first1)) {
      iterator __next = __first2;
      transfer(__first1, __first2, ++__next);
      __first2 = __next;
    }
    else
      ++__first1;
  if (__first2 != __last2) transfer(__last1, __first2, __last2);
}

template <class _Tp, class _Alloc> template <class _StrictWeakOrdering>
void list<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp)
{

  if (_M_node->_M_next != _M_node && _M_node->_M_next->_M_next != _M_node) {
    list<_Tp, _Alloc> __carry;
    list<_Tp, _Alloc> __counter[64];
    int __fill = 0;
    while (!empty()) {
      __carry.splice(__carry.begin(), *this, begin());
      int __i = 0;
      while(__i < __fill && !__counter[__i].empty()) {
        __counter[__i].merge(__carry, __comp);
        __carry.swap(__counter[__i++]);
      }
      __carry.swap(__counter[__i]);
      if (__i == __fill) ++__fill;
    }

    for (int __i = 1; __i < __fill; ++__i)
      __counter[__i].merge(__counter[__i-1], __comp);
    swap(__counter[__fill-1]);
  }
}
# 879 "/opt/gcc3/include/g++-v3/bits/stl_list.h" 3
}
# 35 "/opt/gcc3/include/g++-v3/bits/std_list.h" 2 3
# 3 "/opt/gcc3/include/g++-v3/list" 2 3
# 136 "../include/CORBA.h" 2



namespace std {
    typedef int ____foo____;
};
using namespace std;





typedef vector<int>::size_type mico_vec_size_type;




# 1 "../include/mico/version.h" 1
# 154 "../include/CORBA.h" 2
# 1 "../include/mico/types.h" 1
# 29 "../include/mico/types.h"
typedef short MICO_Short;





typedef long MICO_Long;
# 45 "../include/mico/types.h"
typedef long long MICO_LongLong;







typedef unsigned short MICO_UShort;





typedef unsigned long MICO_ULong;
# 69 "../include/mico/types.h"
typedef unsigned long long MICO_ULongLong;







typedef float MICO_Float;





typedef double MICO_Double;




typedef long double MICO_LongDouble;



typedef char MICO_Char;
typedef unsigned char MICO_Boolean;
typedef unsigned char MICO_Octet;




typedef wchar_t MICO_WChar;
# 155 "../include/CORBA.h" 2
# 1 "../include/mico/sequence.h" 1
# 27 "../include/mico/sequence.h"
template<class T> class TSeqVar;







template<class T, int TID>
class SequenceTmpl {
public:
    typedef T &ElementType;
    typedef TSeqVar<SequenceTmpl<T,TID> > _var_type;
private:
    vector<T> vec;
public:
    SequenceTmpl () {}
    SequenceTmpl (MICO_ULong maxval)
    {
        vec.reserve (maxval);
    }
    SequenceTmpl (MICO_ULong max, MICO_ULong length, T *value,
                  MICO_Boolean rel = 0);

    SequenceTmpl (const SequenceTmpl<T,TID> &s)
    {
        vec = s.vec;
    }

    ~SequenceTmpl ()
    {
    }

    void replace (MICO_ULong max, MICO_ULong length, T *value,
                  MICO_Boolean rel = 0);

    SequenceTmpl<T,TID> &operator= (const SequenceTmpl<T,TID> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return vec.capacity ();
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    T* get_buffer (MICO_Boolean orphan = 0);

    const T* get_buffer () const
    {
        ((void) ((vec.size() > 0) ? 0 : (__assert_fail ("vec.size() > 0", "../include/mico/sequence.h", 84, __PRETTY_FUNCTION__), 0)));
        return &vec[0];
    }

    void length (MICO_ULong l);

    MICO_ULong length () const;
    T &operator[] (MICO_ULong idx);
    const T &operator[] (MICO_ULong idx) const;

    static T *allocbuf (MICO_ULong len)
    {
        return new T[len];
    }

    static void freebuf (T *b)
    {
        delete[] b;
    }
# 117 "../include/mico/sequence.h"
};

template<class T, int TID>
SequenceTmpl<T,TID>::SequenceTmpl (MICO_ULong maxval, MICO_ULong lengthval, T *value,
                                   MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence.h", 123, __PRETTY_FUNCTION__), 0)));
    vec.reserve (maxval);
    vec.insert (vec.begin(), value, value+lengthval);
    if (rel)
        freebuf (value);
}

template<class T, int TID>
void
SequenceTmpl<T,TID>::replace (MICO_ULong maxval, MICO_ULong lengthval, T *value,
                              MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence.h", 135, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (maxval);
    vec.insert (vec.begin(), value, value+lengthval);
    if (rel)
        freebuf (value);
}

template<class T, int TID>
void
SequenceTmpl<T,TID>::length (MICO_ULong l)
{
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;

        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}

template<class T, int TID>
inline MICO_ULong
SequenceTmpl<T,TID>::length () const
{
    return vec.size ();
}

template<class T, int TID>
inline T &
SequenceTmpl<T,TID>::operator[] (MICO_ULong idx)
{
    return vec[idx];
}


template<class T, int TID>
inline const T &
SequenceTmpl<T,TID>::operator[] (MICO_ULong idx) const
{
    return vec[idx];
}

template<class T, int TID>
T *
SequenceTmpl<T,TID>::get_buffer (MICO_Boolean orphan)
{
    if (orphan) {
        T *b = allocbuf (vec.capacity());
        for (mico_vec_size_type i = 0; i < vec.size(); ++i)
            b[i] = vec[i];
        vec.erase (vec.begin(), vec.end());
        return b;
    } else {
        ((void) ((vec.size() > 0) ? 0 : (__assert_fail ("vec.size() > 0", "../include/mico/sequence.h", 189, __PRETTY_FUNCTION__), 0)));
        return &vec[0];
    }
}


template<class T, int TID>
MICO_Boolean
operator== (const SequenceTmpl<T,TID> &v1, const SequenceTmpl<T,TID> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}





template<class T, int TID, int max>
class BoundedSequenceTmpl {
public:
    typedef T &ElementType;
private:
    vector<T> vec;
public:
    BoundedSequenceTmpl ()
    {
        vec.reserve (max);
    }
    BoundedSequenceTmpl (MICO_ULong length, T *value,
                         MICO_Boolean rel = 1);

    BoundedSequenceTmpl (const BoundedSequenceTmpl<T, TID, max> &s)
    {
        vec = s.vec;
    }

    ~BoundedSequenceTmpl ()
    {
    }

    void replace (MICO_ULong length, T *value,
                  MICO_Boolean rel = 1);

    BoundedSequenceTmpl<T, TID, max> &operator=
        (const BoundedSequenceTmpl<T, TID, max> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return max;
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    T* get_buffer (MICO_Boolean orphan = 0);

    const T* get_buffer () const
    {
        ((void) ((vec.size() > 0) ? 0 : (__assert_fail ("vec.size() > 0", "../include/mico/sequence.h", 260, __PRETTY_FUNCTION__), 0)));
        return &vec[0];
    }

    void length (MICO_ULong l);

    MICO_ULong length () const
    {
        return vec.size ();
    }

    T &operator[] (MICO_ULong idx)
    {
        return vec[idx];
    }

    const T &operator[] (MICO_ULong idx) const
    {
        return vec[idx];
    }

    static T *allocbuf (MICO_ULong len)
    {
        return new T[len];
    }

    static void freebuf (T *b)
    {
        delete[] b;
    }
# 305 "../include/mico/sequence.h"
};

template<class T, int TID, int max>
BoundedSequenceTmpl<T,TID,max>::BoundedSequenceTmpl (MICO_ULong lengthval,
                                                     T *value,
                                                     MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence.h", 312, __PRETTY_FUNCTION__), 0)));
    vec.reserve (max);
    vec.insert (vec.begin(), value, value+lengthval);
    if (rel)
        freebuf (value);
}

template<class T, int TID, int max>
void
BoundedSequenceTmpl<T,TID,max>::replace (MICO_ULong lengthval,
                                         T *value, MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence.h", 324, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (max);
    vec.insert (vec.begin(), value, value+lengthval);
    if (rel)
        freebuf (value);
}

template<class T, int TID, int max>
void
BoundedSequenceTmpl<T,TID,max>::length (MICO_ULong l)
{
    ((void) ((l <= max) ? 0 : (__assert_fail ("l <= max", "../include/mico/sequence.h", 336, __PRETTY_FUNCTION__), 0)));
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;
        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}


template<class T, int TID, int max>
T *
BoundedSequenceTmpl<T,TID,max>::get_buffer (MICO_Boolean orphan)
{
    if (orphan) {
        T *b = allocbuf (vec.capacity());
        for (mico_vec_size_type i = 0; i < vec.size(); ++i)
            b[i] = vec[i];
        vec.erase (vec.begin(), vec.end());
        return b;
    } else {
        ((void) ((vec.size() > 0) ? 0 : (__assert_fail ("vec.size() > 0", "../include/mico/sequence.h", 357, __PRETTY_FUNCTION__), 0)));
        return &vec[0];
    }
}


template<class T, int TID, int max>
MICO_Boolean
operator== (const BoundedSequenceTmpl<T,TID,max> &v1,
            const BoundedSequenceTmpl<T,TID,max> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}
# 387 "../include/mico/sequence.h"
template<class T_elem, class T, MICO_ULong n>
class SequenceIndTmpl {
public:
  typedef T &ElementType;
private:
  vector<T_elem*> vec;
public:
  SequenceIndTmpl () {}
  SequenceIndTmpl (MICO_ULong maxval)
  {
    vec.reserve (maxval);
  }
  SequenceIndTmpl (MICO_ULong max, MICO_ULong length, T* value,
                   MICO_Boolean rel = 1);

  void replace (MICO_ULong max, MICO_ULong length, T *value,
                MICO_Boolean rel = 1);

  SequenceIndTmpl (const SequenceIndTmpl<T_elem,T,n> &s);

  ~SequenceIndTmpl ();

  SequenceIndTmpl<T_elem,T,n>&
  operator= (const SequenceIndTmpl<T_elem,T,n> &s);

  MICO_ULong maximum () const
  {
    return vec.capacity ();
  }

  void length (MICO_ULong l);

  MICO_ULong length () const
  {
    return vec.size ();
  }

  MICO_Boolean release () const
  {

    return 1;
  }



  T& operator[] (MICO_ULong idx)
  {
    return (T&) *vec[idx];
  }

  const T& operator[] (MICO_ULong idx) const
  {
    return (T&) *vec[idx];
  }

  static T *allocbuf (MICO_ULong len);

  static void freebuf( T* b );
# 464 "../include/mico/sequence.h"
};


template<class T_elem, class T, MICO_ULong n>
MICO_Boolean
operator== (const SequenceIndTmpl<T_elem,T,n> &v1,
            const SequenceIndTmpl<T_elem,T,n> &v2)
{
  if( v1.length() != v2.length() )
    return 0;
  for( MICO_ULong i = 0; i < v1.length(); i++ ) {
    for( MICO_ULong j = 0; j < n; j++ ) {
      T_elem e1 = ((T_elem*) v1[ i ])[ j ];
      T_elem e2 = ((T_elem*) v2[ i ])[ j ];
      if( !(e1 == e2) )
        return 0;
    }
  }
  return 1;
}





template<class T_elem, class T, MICO_ULong n, int max>
class BoundedSequenceIndTmpl {
public:
  typedef T &ElementType;
private:
  vector<T_elem*> vec;
public:
  BoundedSequenceIndTmpl ()
  {
    vec.reserve (max);
  }
  BoundedSequenceIndTmpl (MICO_ULong length, T *value,
                          MICO_Boolean rel = 1);

  BoundedSequenceIndTmpl
  (const BoundedSequenceIndTmpl<T_elem,T,n,max> &s);

  ~BoundedSequenceIndTmpl ();

  BoundedSequenceIndTmpl<T_elem,T,n, max> &operator=
  (const BoundedSequenceIndTmpl<T_elem,T,n, max> &s);

  void replace (MICO_ULong length, T *value,
                MICO_Boolean rel = 1);

  MICO_ULong maximum () const
  {
    return max;
  }

  void length (MICO_ULong l);

  MICO_ULong length () const
  {
    return vec.size ();
  }

  MICO_Boolean release () const
  {

    return 1;
  }



  T &operator[] (MICO_ULong idx)
  {
    return (T&) *vec[idx];
  }

  const T &operator[] (MICO_ULong idx) const
  {
    return (T&) *vec[idx];
  }

  static T *allocbuf (MICO_ULong len);

  static void freebuf (T *b);
# 566 "../include/mico/sequence.h"
};


template<class T_elem, class T, MICO_ULong n, int max>
MICO_Boolean
operator== (const BoundedSequenceIndTmpl<T_elem,T,n,max> &v1,
            const BoundedSequenceIndTmpl<T_elem,T,n,max> &v2)
{
  if( v1.length() != v2.length() )
    return 0;
  for( MICO_ULong i = 0; i < v1.length(); i++ ) {
    for( MICO_ULong j = 0; j < n; j++ ) {
      T_elem e1 = ((T_elem*) v1[ i ])[ j ];
      T_elem e2 = ((T_elem*) v2[ i ])[ j ];
      if( !(e1 == e2) )
        return 0;
    }
  }
  return 1;
}
# 156 "../include/CORBA.h" 2
# 1 "../include/mico/sequence_special.h" 1
# 43 "../include/mico/sequence_special.h"
template<class T>
class StringSequenceTmpl {
public:
    typedef T &ElementType;
    typedef TSeqVar<StringSequenceTmpl<T> > _var_type;
private:
    vector<T> vec;
public:
    StringSequenceTmpl () {}
    StringSequenceTmpl (MICO_ULong maxval)
    {
        vec.reserve (maxval);
    }
    StringSequenceTmpl (MICO_ULong max, MICO_ULong length, char** value,
                        MICO_Boolean rel = 0);

    StringSequenceTmpl (const StringSequenceTmpl<T> &s)
    {
        vec = s.vec;
    }

    ~StringSequenceTmpl ()
    {
    }

    void replace (MICO_ULong max, MICO_ULong length, char** value,
                  MICO_Boolean rel = 0);

    StringSequenceTmpl<T> &operator= (const StringSequenceTmpl<T> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return vec.capacity ();
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    char **get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 91, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const char **get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 98, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const;
    T& operator[] (MICO_ULong idx);
    const T &operator[] (MICO_ULong idx) const;

    static char **allocbuf (MICO_ULong len)
    {
        return new char*[len];
    }

    static void freebuf (char **b)
    {
        delete[] b;
    }
# 132 "../include/mico/sequence_special.h"
};

template<class T>
StringSequenceTmpl<T>::StringSequenceTmpl (MICO_ULong maxval,
                                           MICO_ULong lengthval,
                                           char** value,
                                           MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 140, __PRETTY_FUNCTION__), 0)));
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const char *)value[i] );
        }
    }
}

template<class T>
void
StringSequenceTmpl<T>::replace (MICO_ULong maxval, MICO_ULong lengthval,
                                char** value, MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 156, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const char *)value[i] );
        }
    }
}

template<class T>
void
StringSequenceTmpl<T>::length (MICO_ULong l)
{
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;

        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}

template<class T>
inline MICO_ULong
StringSequenceTmpl<T>::length () const
{
    return vec.size ();
}

template<class T>
inline T&
StringSequenceTmpl<T>::operator[] (MICO_ULong idx)
{
    return vec[idx];
}


template<class T>
inline const T&
StringSequenceTmpl<T>::operator[] (MICO_ULong idx) const
{
    return vec[idx];
}


template<class T>
MICO_Boolean
operator== (const StringSequenceTmpl<T> &v1, const StringSequenceTmpl<T> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}






template<class T, int max>
class BoundedStringSequenceTmpl {
public:
    typedef T &ElementType;
private:
    vector<T> vec;
public:
    BoundedStringSequenceTmpl ()
    {
        vec.reserve (max);
    }
    BoundedStringSequenceTmpl (MICO_ULong length, char** value,
                               MICO_Boolean rel = 1);

    BoundedStringSequenceTmpl (const BoundedStringSequenceTmpl<T,max> &s)
    {
        vec = s.vec;
    }

    ~BoundedStringSequenceTmpl ()
    {
    }

    void replace (MICO_ULong length, char** value,
                  MICO_Boolean rel = 1);

    BoundedStringSequenceTmpl<T,max> &operator=
        (const BoundedStringSequenceTmpl<T,max> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return max;
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    char **get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 269, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const char **get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 276, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const
    {
        return vec.size ();
    }

    T &operator[] (MICO_ULong idx)
    {
        return vec[idx];
    }

    const T &operator[] (MICO_ULong idx) const
    {
        return vec[idx];
    }

    static char **allocbuf (MICO_ULong len)
    {
        return new char*[len];
    }

    static void freebuf (char **b)
    {
        delete[] b;
    }
# 321 "../include/mico/sequence_special.h"
};

template<class T, int max>
BoundedStringSequenceTmpl<T,max>::BoundedStringSequenceTmpl (MICO_ULong lengthval,
                                                             char** value,
                                                             MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 328, __PRETTY_FUNCTION__), 0)));
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const char *)value[i] );
        }
    }
}

template<class T, int max>
void
BoundedStringSequenceTmpl<T,max>::replace (MICO_ULong lengthval,
                                           char** value,
                                           MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 345, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const char *)value[i] );
        }
    }
}

template<class T, int max>
void
BoundedStringSequenceTmpl<T,max>::length (MICO_ULong l)
{
    ((void) ((l <= max) ? 0 : (__assert_fail ("l <= max", "../include/mico/sequence_special.h", 361, __PRETTY_FUNCTION__), 0)));
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;
        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}


template<class T, int max>
MICO_Boolean
operator== (const BoundedStringSequenceTmpl<T,max> &v1,
            const BoundedStringSequenceTmpl<T,max> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}





template<class T>
class WStringSequenceTmpl {
public:
    typedef T &ElementType;
    typedef TSeqVar<WStringSequenceTmpl<T> > _var_type;
private:
    vector<T> vec;
public:
    WStringSequenceTmpl () {}
    WStringSequenceTmpl (MICO_ULong maxval)
    {
        vec.reserve (maxval);
    }
    WStringSequenceTmpl (MICO_ULong max, MICO_ULong length, wchar_t** value,
                         MICO_Boolean rel = 0);

    WStringSequenceTmpl (const WStringSequenceTmpl<T> &s)
    {
        vec = s.vec;
    }

    ~WStringSequenceTmpl ()
    {
    }

    void replace (MICO_ULong max, MICO_ULong length, wchar_t** value,
                  MICO_Boolean rel = 0);

    WStringSequenceTmpl<T> &operator= (const WStringSequenceTmpl<T> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return vec.capacity ();
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    wchar_t **get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 437, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const wchar_t **get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 444, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const;
    T& operator[] (MICO_ULong idx);
    const T &operator[] (MICO_ULong idx) const;

    static wchar_t **allocbuf (MICO_ULong len)
    {
        return new wchar_t*[len];
    }

    static void freebuf (wchar_t **b)
    {
        delete[] b;
    }
# 478 "../include/mico/sequence_special.h"
};

template<class T>
WStringSequenceTmpl<T>::WStringSequenceTmpl (MICO_ULong maxval,
                                             MICO_ULong lengthval,
                                             wchar_t** value,
                                             MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 486, __PRETTY_FUNCTION__), 0)));
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const wchar_t *)value[i] );
        }
    }
}

template<class T>
void
WStringSequenceTmpl<T>::replace (MICO_ULong maxval, MICO_ULong lengthval,
                                 wchar_t** value, MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 502, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const wchar_t *)value[i] );
        }
    }
}

template<class T>
void
WStringSequenceTmpl<T>::length (MICO_ULong l)
{
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;

        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}

template<class T>
inline MICO_ULong
WStringSequenceTmpl<T>::length () const
{
    return vec.size ();
}

template<class T>
inline T &
WStringSequenceTmpl<T>::operator[] (MICO_ULong idx)
{
    return vec[idx];
}


template<class T>
inline const T &
WStringSequenceTmpl<T>::operator[] (MICO_ULong idx) const
{
    return vec[idx];
}


template<class T>
MICO_Boolean
operator== (const WStringSequenceTmpl<T> &v1, const WStringSequenceTmpl<T> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}






template<class T, int max>
class BoundedWStringSequenceTmpl {
public:
    typedef T &ElementType;
private:
    vector<T> vec;
public:
    BoundedWStringSequenceTmpl ()
    {
        vec.reserve (max);
    }
    BoundedWStringSequenceTmpl (MICO_ULong length, wchar_t** value,
                                MICO_Boolean rel = 1);

    BoundedWStringSequenceTmpl (const BoundedWStringSequenceTmpl<T,max> &s)
    {
        vec = s.vec;
    }

    ~BoundedWStringSequenceTmpl ()
    {
    }

    void replace (MICO_ULong length, wchar_t** value,
                  MICO_Boolean rel = 1);

    BoundedWStringSequenceTmpl<T,max> &operator=
        (const BoundedWStringSequenceTmpl<T,max> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return max;
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    wchar_t **get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 615, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const wchar_t **get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 622, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const
    {
        return vec.size ();
    }

    T &operator[] (MICO_ULong idx)
    {
        return vec[idx];
    }

    const T &operator[] (MICO_ULong idx) const
    {
        return vec[idx];
    }

    static wchar_t **allocbuf (MICO_ULong len)
    {
        return new wchar_t*[len];
    }

    static void freebuf (wchar_t **b)
    {
        delete[] b;
    }
# 667 "../include/mico/sequence_special.h"
};

template<class T, int max>
BoundedWStringSequenceTmpl<T,max>::BoundedWStringSequenceTmpl (MICO_ULong lengthval,
                                                               wchar_t** value,
                                                               MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 674, __PRETTY_FUNCTION__), 0)));
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const wchar_t *)value[i] );
        }
    }
}

template<class T, int max>
void
BoundedWStringSequenceTmpl<T,max>::replace (MICO_ULong lengthval,
                                            wchar_t** value,
                                            MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 691, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( (const wchar_t *)value[i] );
        }
    }
}

template<class T, int max>
void
BoundedWStringSequenceTmpl<T,max>::length (MICO_ULong l)
{
    ((void) ((l <= max) ? 0 : (__assert_fail ("l <= max", "../include/mico/sequence_special.h", 707, __PRETTY_FUNCTION__), 0)));
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;
        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}


template<class T, int max>
MICO_Boolean
operator== (const BoundedWStringSequenceTmpl<T,max> &v1,
            const BoundedWStringSequenceTmpl<T,max> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!(v1[_i] == v2[_i]))
            return 0;
    }
    return 1;
}





template<class T, class T_ptr>
class IfaceSequenceTmpl {
public:
    typedef T &ElementType;
    typedef TSeqVar<IfaceSequenceTmpl<T,T_ptr> > _var_type;
private:
    vector<T> vec;
public:
    IfaceSequenceTmpl () {}
    IfaceSequenceTmpl (MICO_ULong maxval)
    {
        vec.reserve (maxval);
    }
    IfaceSequenceTmpl (MICO_ULong max, MICO_ULong length, T_ptr* value,
                       MICO_Boolean rel = 0);

    IfaceSequenceTmpl (const IfaceSequenceTmpl<T,T_ptr> &s)
    {
        vec = s.vec;
    }

    ~IfaceSequenceTmpl ()
    {
    }

    void replace (MICO_ULong max, MICO_ULong length, T_ptr* value,
                  MICO_Boolean rel = 0);

    IfaceSequenceTmpl<T,T_ptr> &operator= (const IfaceSequenceTmpl<T,T_ptr> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return vec.capacity ();
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    T_ptr *get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 783, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const T_ptr *get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 790, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const;
    T &operator[] (MICO_ULong idx);
    const T& operator[] (MICO_ULong idx) const;

    static T_ptr *allocbuf (MICO_ULong len)
    {
        return new T_ptr[len];
    }

    static void freebuf (T_ptr *b)
    {
        delete[] b;
    }
# 824 "../include/mico/sequence_special.h"
};


template<class T, class T_ptr>
IfaceSequenceTmpl<T,T_ptr>::IfaceSequenceTmpl (MICO_ULong maxval,
                                               MICO_ULong lengthval,
                                               T_ptr* value,
                                               MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 833, __PRETTY_FUNCTION__), 0)));
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( T::duplicate (value[i]) );
        }
    }
}

template<class T, class T_ptr>
void
IfaceSequenceTmpl<T,T_ptr>::replace (MICO_ULong maxval, MICO_ULong lengthval,
                                     T_ptr* value, MICO_Boolean rel)
{
    ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/sequence_special.h", 849, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (maxval);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( T::duplicate (value[i]) );
        }
    }
}


template<class T, class T_ptr>
void
IfaceSequenceTmpl<T,T_ptr>::length (MICO_ULong l)
{
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;

        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}

template<class T, class T_ptr>
inline MICO_ULong
IfaceSequenceTmpl<T,T_ptr>::length () const
{
    return vec.size ();
}

template<class T, class T_ptr>
inline T &
IfaceSequenceTmpl<T,T_ptr>::operator[] (MICO_ULong idx)
{
    return vec[idx];
}


template<class T, class T_ptr>
inline const T &
IfaceSequenceTmpl<T,T_ptr>::operator[] (MICO_ULong idx) const
{
    return vec[idx];
}


template<class T, class T_ptr>
MICO_Boolean
operator== (const IfaceSequenceTmpl<T,T_ptr> &v1,
            const IfaceSequenceTmpl<T,T_ptr> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!v1[_i]->_is_equivalent (v2[_i]))
            return 0;
    }
    return 1;
}






template<class T, class T_ptr, int max>
class BoundedIfaceSequenceTmpl {
public:
    typedef T &ElementType;
private:
    vector<T> vec;
public:
    BoundedIfaceSequenceTmpl ()
    {
        vec.reserve (max);
    }
    BoundedIfaceSequenceTmpl (MICO_ULong length, T_ptr* value,
                              MICO_Boolean rel = 1);

    BoundedIfaceSequenceTmpl (const BoundedIfaceSequenceTmpl<T,T_ptr,max> &s)
    {
        vec = s.vec;
    }

    ~BoundedIfaceSequenceTmpl ()
    {
    }

    void replace (MICO_ULong length, T_ptr* value,
                  MICO_Boolean rel = 1);

    BoundedIfaceSequenceTmpl<T,T_ptr,max> &operator=
        (const BoundedIfaceSequenceTmpl<T,T_ptr,max> &s)
    {
        vec = s.vec;
        return *this;
    }

    MICO_ULong maximum () const
    {
        return max;
    }

    MICO_Boolean release () const
    {

        return 1;
    }

    T_ptr* get_buffer (MICO_Boolean orphan = 0)
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 964, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    const T_ptr* get_buffer () const
    {

        ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/sequence_special.h", 971, __PRETTY_FUNCTION__), 0)));
        return 0;
    }

    void length (MICO_ULong l);

    MICO_ULong length () const
    {
        return vec.size ();
    }

    T &operator[] (MICO_ULong idx)
    {
        return vec[idx];
    }

    const T &operator[] (MICO_ULong idx) const
    {
        return vec[idx];
    }

    static T_ptr *allocbuf (MICO_ULong len)
    {
        return new T_ptr[len];
    }

    static void freebuf (T_ptr *b)
    {
        delete[] b;
    }
# 1016 "../include/mico/sequence_special.h"
};


template<class T, class T_ptr, int max>
BoundedIfaceSequenceTmpl<T,T_ptr,max>::
         BoundedIfaceSequenceTmpl (MICO_ULong lengthval,
                                   T_ptr* value,
                                   MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 1025, __PRETTY_FUNCTION__), 0)));
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( T::duplicate (value[i]) );
        }
    }
}

template<class T, class T_ptr, int max>
void
BoundedIfaceSequenceTmpl<T,T_ptr,max>::replace (MICO_ULong lengthval,
                                                T_ptr* value,
                                                MICO_Boolean rel)
{
    ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/sequence_special.h", 1042, __PRETTY_FUNCTION__), 0)));
    vec.erase (vec.begin(), vec.end());
    vec.reserve (max);
    for( MICO_ULong i = 0; i < lengthval; i++ ) {
        if (rel) {
            vec.push_back( value[i] );
        } else {
            vec.push_back( T::duplicate (value[i]) );
        }
    }
}


template<class T, class T_ptr, int max>
void
BoundedIfaceSequenceTmpl<T,T_ptr,max>::length (MICO_ULong l)
{
    ((void) ((l <= max) ? 0 : (__assert_fail ("l <= max", "../include/mico/sequence_special.h", 1059, __PRETTY_FUNCTION__), 0)));
    if (l < vec.size ()) {
        vec.erase (vec.begin() + l, vec.end());
    } else if (l > vec.size()) {
        T t;
        vec.insert (vec.end(), long(l - vec.size()), t);
    }
}


template<class T, class T_ptr, int max>
MICO_Boolean
operator== (const BoundedIfaceSequenceTmpl<T,T_ptr,max> &v1,
            const BoundedIfaceSequenceTmpl<T,T_ptr,max> &v2)
{
    if (v1.length() != v2.length())
        return 0;
    for (MICO_ULong _i = 0; _i < v1.length(); ++_i) {
        if (!v1[_i]->_is_equivalent (v2[_i]))
            return 0;
    }
    return 1;
}
# 157 "../include/CORBA.h" 2
# 1 "../include/mico/array.h" 1
# 79 "../include/mico/array.h"
template<class T_elem, class T_slice, class T, MICO_ULong n>
class ArrayFixVar
{
private:
  T_slice *_ptr;

  void free();
  void copy( T_slice* ptr );
  void reset( T_slice* ptr )
  {
    free();
    _ptr = ptr;
  }

public:
  ArrayFixVar()
  {



    _ptr = (T_slice*) new T_elem[ n ];
  }
  ArrayFixVar( T_slice *slice )
  {
    _ptr = slice;
  }
  ArrayFixVar( const ArrayFixVar<T_elem, T_slice, T, n> &arr )
  {
    _ptr = 0;
    copy (arr._ptr);
  }
  ArrayFixVar( const T &arr )
  {
    _ptr = 0;
    copy ((T_slice *)&arr);
  }
  ~ArrayFixVar()
  {
    free();
  }
  ArrayFixVar<T_elem, T_slice, T, n> &
  operator=( const ArrayFixVar<T_elem, T_slice, T, n> &arr )
  {
    if( this != &arr ) {
      copy (arr._ptr);
    }
    return *this;
  }
  ArrayFixVar<T_elem, T_slice, T, n> &
  operator=( T_slice *slice )
  {
    if( _ptr != slice )
      reset( slice );
    return *this;
  }
  T_slice& operator[]( MICO_ULong i )
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 136, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  const T_slice& operator[]( MICO_ULong i ) const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 141, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  operator T_slice*() const
  {
    return _ptr;
  }
  const T_slice *in() const
  {
    return _ptr;
  }
  T_slice *inout()
  {
    return _ptr;
  }
  T_slice *out()
  {
    free();
    return _ptr;
  }
  T_slice *_for_demarshal()
  {
    return out();
  }
  T_slice *_retn()
  {
    T_slice *_p = _ptr;
    _ptr = __null;
    return _p;
  }
};


template<class T_elem, class T_slice, class T, MICO_ULong n>
inline void
ArrayFixVar<T_elem, T_slice, T, n>::free()
{
    if (_ptr)
        delete[] (T_elem*) _ptr;
    _ptr = __null;
}

template<class T_elem, class T_slice, class T, MICO_ULong n>
inline void
ArrayFixVar<T_elem, T_slice, T, n>::copy( T_slice* ptr )
{
    if (!ptr) {
        reset (0);
        return;
    }
    T_slice* s = (T_slice*) new T_elem[ n ];
    reset( s );
    T_elem *dest = (T_elem*) _ptr;
    T_elem *src = (T_elem*) ptr;
    int i = 0;
    while( i < n ) {
        *dest = *src;
        ++dest;
        ++src;
        i++;
    }






}
# 221 "../include/mico/array.h"
template<class T_elem, class T_slice, class T, MICO_ULong n>
class ArrayVarVar
{
private:
  T_slice *_ptr;

  void free();
  void copy( T_slice* ptr );
  void reset( T_slice* ptr )
  {
    free();
    _ptr = ptr;
  }

public:
  ArrayVarVar()
  {



    _ptr = (T_slice*) new T_elem[ n ];
  }
  ArrayVarVar( T_slice *slice )
  {
    _ptr = slice;
  }
  ArrayVarVar( const ArrayVarVar<T_elem, T_slice, T, n> &arr )
  {
    _ptr = 0;
    copy (arr._ptr);
  }
  ArrayVarVar( const T &arr )
  {
    _ptr = 0;
    copy ((T_slice *)&arr);
  }
  ~ArrayVarVar()
  {
    free();
  }
  ArrayVarVar<T_elem, T_slice, T, n> &
  operator=( const ArrayVarVar<T_elem, T_slice, T, n> &arr )
  {
    if( this != &arr ) {
      copy (arr._ptr);
    }
    return *this;
  }
  ArrayVarVar<T_elem, T_slice, T, n> &
  operator=( T_slice *slice )
  {
    if( _ptr != slice )
      reset( slice );
    return *this;
  }
  T_slice& operator[]( MICO_ULong i )
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 278, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  const T_slice& operator[]( MICO_ULong i ) const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 283, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  operator const T_slice*() const
  {
    return _ptr;
  }
  const T_slice *in() const
  {
    return _ptr;
  }
  T_slice *inout()
  {
    return _ptr;
  }
  T_slice *&out()
  {
    free();
    return _ptr;
  }
  T_slice *_for_demarshal()
  {
    free();
    return _ptr;
  }
  T_slice *_retn()
  {
    T_slice *_p = _ptr;
    _ptr = __null;
    return _p;
  }
};


template<class T_elem, class T_slice, class T, MICO_ULong n>
inline void
ArrayVarVar<T_elem, T_slice, T, n>::free()
{
    if (_ptr)
        delete[] (T_elem*) _ptr;
    _ptr = __null;
}

template<class T_elem, class T_slice, class T, MICO_ULong n>
inline void
ArrayVarVar<T_elem, T_slice, T, n>::copy( T_slice* ptr )
{
    if (!ptr) {
        reset (0);
        return;
    }
    T_slice* s = (T_slice*) new T_elem[ n ];
    reset( s );
    T_elem *dest = (T_elem*) _ptr;
    T_elem *src = (T_elem*) ptr;
    int i = 0;
    while( i < n ) {
        *dest = *src;
        ++dest;
        ++src;
        i++;
    }






}





template<class T_elem, class T_slice, class T, MICO_ULong n>
class ArrayVarOut
{
private:
    T_slice*& _ptr;

public:
    ArrayVarOut (T_slice*& p)
        : _ptr (p)
        {
            _ptr = __null;
        }
    ArrayVarOut (ArrayVarVar<T_elem,T_slice,T,n>& p)
        : _ptr (p._ptr)
        {
            delete[] _ptr;
            _ptr = __null;
        }
    ArrayVarOut (const ArrayVarOut<T_elem,T_slice,T,n>& p)
        : _ptr (p._ptr)
        {
        }
    T_slice& operator[] (MICO_ULong idx)
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 381, __PRETTY_FUNCTION__), 0)));
            return _ptr[ idx ];
        }

    ArrayVarOut<T_elem,T_slice,T,n>& operator= (const ArrayVarOut<T_elem,T_slice,T,n>& p)
        {
            _ptr = p._ptr;
            return *this;
        }
    ArrayVarOut<T_elem,T_slice,T,n>& operator= (T_slice* p)
        {
            _ptr = p;
            return *this;
        }
    operator T_slice*& ()
        {
            return _ptr;
        }
    T_slice*& ptr ()
        {
            return _ptr;
        }

private:
    void operator= (const ArrayVarVar<T_elem,T_slice,T,n>&);
};
# 423 "../include/mico/array.h"
template<class T_elem, class T_slice, class T, MICO_ULong n, class _dummy>
class ArrayFixForAny
{
private:
  T_slice* _ptr;
  MICO_Boolean _nocopy;

public:
  ArrayFixForAny()
  {
    _ptr = 0;
    _nocopy = 0;
  }
  ArrayFixForAny( T_slice *slice, MICO_Boolean nocopy = false )
  {
    _ptr = slice;
    _nocopy = nocopy;
  }
  ArrayFixForAny( const ArrayFixForAny<T_elem, T_slice, T, n, _dummy> &arr,
               MICO_Boolean nocopy = false )
  {
    _ptr = arr._ptr;
    _nocopy = nocopy;
  }
  ArrayFixForAny<T_elem, T_slice, T, n, _dummy> &
  operator=( T_slice *slice )
  {
    _ptr = slice;
    return *this;
  }
  ArrayFixForAny<T_elem, T_slice, T, n, _dummy> &
  operator=( const ArrayFixForAny<T_elem, T_slice, T, n, _dummy> &arr )
  {
    _ptr = arr._ptr;
    return *this;
  }
  T_slice& operator[]( MICO_ULong i )
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 461, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  const T_slice& operator[]( MICO_ULong i ) const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 466, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
# 480 "../include/mico/array.h"
  operator T_slice*&() const
  {
    return (T_slice*&) _ptr;
  }

  const T_slice *in() const
  {
    return _ptr;
  }
  T_slice *inout()
  {
    return _ptr;
  }
  T_slice *out()
  {
    return _ptr;
  }
  T_slice *_retn()
  {
    T_slice *_p = _ptr;
    _ptr = __null;
    return _p;
  }
  void clear () const
  {
    ArrayFixForAny<T_elem, T_slice, T, n, _dummy> *me =
        (ArrayFixForAny<T_elem, T_slice, T, n, _dummy> *)this;
    if (me->_ptr && me->_nocopy) {
      delete[] (T_elem*)me->_ptr;
      me->_ptr = 0;
    }
  }
  void alloc () const
  {
    ArrayFixForAny<T_elem, T_slice, T, n, _dummy> *me =
        (ArrayFixForAny<T_elem, T_slice, T, n, _dummy> *)this;
    if (!me->_ptr) {
      me->_ptr = (T_slice*) new T_elem[ n ];
      me->_nocopy = 1;
    }
  }
};


template<class T_elem, class T_slice, class T, MICO_ULong n, class _dummy>
class ArrayVarForAny
{
private:
  T_slice* _ptr;
  MICO_Boolean _nocopy;

public:
  ArrayVarForAny()
  {
    _ptr = 0;
    _nocopy = 1;
  }
  ArrayVarForAny( T_slice *slice, MICO_Boolean nocopy = false )
  {
    _ptr = slice;
    _nocopy = nocopy;
  }
  ArrayVarForAny( const ArrayVarForAny<T_elem, T_slice, T, n, _dummy> &arr,
               MICO_Boolean nocopy = false )
  {
    _ptr = arr._ptr;
    _nocopy = nocopy;
  }
  ArrayVarForAny<T_elem, T_slice, T, n, _dummy> &
  operator=( T_slice *slice )
  {
    _ptr = slice;
    return *this;
  }
  ArrayVarForAny<T_elem, T_slice, T, n, _dummy> &
  operator=( const ArrayVarForAny<T_elem, T_slice, T, n, _dummy> &arr )
  {
    _ptr = arr._ptr;
    return *this;
  }
  T_slice& operator[]( MICO_ULong i )
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 562, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
  const T_slice& operator[]( MICO_ULong i ) const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/array.h", 567, __PRETTY_FUNCTION__), 0)));
    return _ptr[ i ];
  }
# 581 "../include/mico/array.h"
  operator T_slice*&() const
  {
    return (T_slice*&) _ptr;
  }

  const T_slice *in() const
  {
    return _ptr;
  }
  T_slice *inout()
  {
    return _ptr;
  }
  T_slice *&out()
  {
    return _ptr;
  }
  T_slice *_retn()
  {
    T_slice *_p = _ptr;
    _ptr = __null;
    return _p;
  }
  void clear () const
  {
    ArrayVarForAny<T_elem, T_slice, T, n, _dummy> *me =
        (ArrayVarForAny<T_elem, T_slice, T, n, _dummy> *)this;
    if (me->_ptr && me->_nocopy) {
      delete[] (T_elem*)me->_ptr;
      me->_ptr = 0;
    }
  }
  void alloc () const
  {
    ArrayVarForAny<T_elem, T_slice, T, n, _dummy> *me =
        (ArrayVarForAny<T_elem, T_slice, T, n, _dummy> *)this;
    if (!me->_ptr) {
      me->_ptr = (T_slice*) new T_elem[ n ];
      me->_nocopy = 1;
    }
  }
};
# 158 "../include/CORBA.h" 2
# 1 "../include/mico/template.h" 1
# 31 "../include/mico/template.h"
template<class T> class ObjOut;

template<class T>
class ObjVar
{

    friend class ObjOut<T>;

private:
  T* _ptr;

  static T* nil()
  {
      return 0;
  }

public:
  static T* duplicate (T *);
  static void release (T *);

private:
  void free();
  void reset( T* ptr )
  {
      free();
      _ptr = ptr;
  }

public:
  ObjVar()
  {
      _ptr = nil();
  }
  ObjVar( T* ptr )
  {
      _ptr = ptr;
  }
  ObjVar( const ObjVar<T>& var )
  {
      _ptr = duplicate (var._ptr);
  }
  ~ObjVar()
  {
      free();
  }
  ObjVar<T>& operator=( const ObjVar<T> &var )
  {
      if (this != &var) {
          free();
          _ptr = duplicate( var._ptr );
      }
      return *this;
  }
  ObjVar<T>& operator=( T* ptr )
  {
      if (_ptr != ptr)
          reset( ptr );
      return *this;
  }







  operator T* ()
  {
     return _ptr;
  }
  T* operator->() const
  {
      ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 103, __PRETTY_FUNCTION__), 0)));
      return _ptr;
  }

  T* in() const
  {
    return _ptr;
  }

  T*& inout()
  {
    return _ptr;
  }

  T*& out()
  {
    free();
    return _ptr;
  }

  T*& _for_demarshal()
  {
    return out();
  }

  T* _retn()
  {
      T *_p = _ptr;
      _ptr = nil();
      return _p;
  }
};

template<class T>
inline void
ObjVar<T>::free()
{
    release( _ptr );
    _ptr = nil();
}





template<class T>
class ObjOut
{
private:
    T*& _ptr;

public:
    ObjOut (T*& p);
    ObjOut (ObjVar<T>& p);
    ObjOut (const ObjOut<T>& p)
        : _ptr (p._ptr)
        {
        }
    ObjOut<T>& operator= (const ObjOut<T>& p)
        {
            _ptr = p._ptr;
            return *this;
        }
    ObjOut<T>& operator= (const ObjVar<T>& p);
    ObjOut<T>& operator= (T* p)
        {
            _ptr = p;
            return *this;
        }
    operator T& ()
        {
            return *_ptr;
        }
    operator T*& ()
        {
            return _ptr;
        }
    T* operator-> ()
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 182, __PRETTY_FUNCTION__), 0)));
            return _ptr;
        }
    T*& ptr ()
        {
            return _ptr;
        }
};







template <class T> class ValueOut;

template<class T>
class ValueVar
{

    friend class ValueOut<T>;

private:
  T* _ptr;

  static T* nil()
  {
      return 0;
  }
  static T* duplicate (T *);
  static void release (T *);

  void free();
  void reset( T* ptr )
  {
      free();
      _ptr = ptr;
  }
public:
  ValueVar()
  {
      _ptr = nil();
  }
  ValueVar( T* ptr )
  {
      _ptr = ptr;
  }
  ValueVar( const ValueVar<T>& var )
  {
      _ptr = duplicate (var._ptr);
  }
  ~ValueVar()
  {
      free();
  }
  ValueVar<T>& operator=( const ValueVar<T> &var )
  {
      if (this != &var) {
          free();
          _ptr = duplicate( var._ptr );
      }
      return *this;
  }
  ValueVar<T>& operator=( T* ptr )
  {
      if (_ptr != ptr)
          reset( ptr );
      return *this;
  }







  operator T* ()
  {
    return _ptr;
  }
  T* operator->() const
  {
      ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 265, __PRETTY_FUNCTION__), 0)));
      return _ptr;
  }

  T* in() const
  {
    return _ptr;
  }

  T*& inout()
  {
    return _ptr;
  }

  T*& out()
  {
    free();
    return _ptr;
  }

  T*& _for_demarshal()
  {
    return out();
  }

  T* _retn()
  {
      T *_p = _ptr;
      _ptr = nil();
      return _p;
  }
};

template<class T>
inline void
ValueVar<T>::free()
{
    release( _ptr );
    _ptr = nil();
}





template<class T>
class ValueOut
{
private:
    T*& _ptr;

    static T* nil()
        {
            return 0;
        }

public:
    ValueOut (T*& p)
        : _ptr (p)
        {
            _ptr = nil();
        }
    ValueOut (ValueVar<T>& p)
        : _ptr (p._ptr)
        {
            release (_ptr);
            _ptr = nil();
        }
    ValueOut (const ValueOut<T>& p)
        : _ptr (p._ptr)
        {
        }
    ValueOut<T>& operator= (const ValueOut<T>& p)
        {
            _ptr = p._ptr;
            return *this;
        }
    ValueOut<T>& operator= (T* p)
        {
            _ptr = p;
            return *this;
        }
    operator T* ()
        {
            return _ptr;
        }
    T* operator-> ()
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 353, __PRETTY_FUNCTION__), 0)));
            return _ptr;
        }
    T*& ptr ()
        {
            return _ptr;
        }

private:
    void operator= (const ValueVar<T>& p);
};
# 372 "../include/mico/template.h"
template<class T>
class TFixVar
{
private:
  T* _ptr;

  void free();
  void reset( T* ptr )
  {
    free();
    _ptr = ptr;
  }
public:
  TFixVar()
  {
    _ptr = __null;
  }
  TFixVar( T* ptr )
  {
    _ptr = ptr;
  }
  TFixVar( const TFixVar<T>& var )
  {
    if( !var._ptr )
      _ptr = __null;
    else
      _ptr = new T (*var._ptr);
  }
  ~TFixVar()
  {
    free();
  }
  TFixVar<T>& operator=( T* ptr )
  {
    if( _ptr != ptr )
      reset( ptr );
    return *this;
  }
  TFixVar<T>& operator=( const TFixVar<T>& var )
  {
    if( this != &var ) {
      free();
      if( !var._ptr )
        _ptr = __null;
      else
        _ptr = new T (*var._ptr);
    }
    return *this;
  }
# 433 "../include/mico/template.h"
  operator T&() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 435, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }

  operator T* ()
  {
    return _ptr;
  }
  T* operator->() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 445, __PRETTY_FUNCTION__), 0)));
    return _ptr;
  }
  T& operator*() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 450, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }

  const T& in() const
  {
    return *_ptr;
  }

  T& inout()
  {
    return *_ptr;
  }

  T& out()
  {
    free();
    return *_ptr;
  }

  T& _for_demarshal()
  {
    return out();
  }

  T* _retn()
  {
    T *_p = _ptr;
    _ptr = __null;
    return _p;
  }
};

template<class T>
inline void
TFixVar<T>::free()
{
    if( _ptr )
        delete _ptr;
    _ptr = __null;
}






template <class T> class TVarOut;

template<class T>
class TVarVar
{

    friend class TVarOut<T>;

private:
  T* _ptr;

  void free();
  void reset( T* ptr )
  {
    free();
    _ptr = ptr;
  }
public:
  TVarVar()
  {
    _ptr = __null;
  }
  TVarVar( T* ptr )
  {
    _ptr = ptr;
  }
  TVarVar( const TVarVar<T>& var )
  {
    if( !var._ptr )
      _ptr = __null;
    else
      _ptr = new T (*var._ptr);
  }
  ~TVarVar()
  {
    free();
  }
  TVarVar<T>& operator=( T* ptr )
  {
    if( _ptr != ptr )
      reset( ptr );
    return *this;
  }
  TVarVar<T>& operator=( const TVarVar<T>& var )
  {
    if( this != &var ) {
      free();
      if( !var._ptr )
        _ptr = __null;
      else
        _ptr = new T (*var._ptr);
    }
    return *this;
  }
# 563 "../include/mico/template.h"
  operator T&() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 565, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }

  operator T* ()
  {
    return _ptr;
  }
  T* operator->() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 575, __PRETTY_FUNCTION__), 0)));
    return _ptr;
  }
  T& operator*() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 580, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }
  const T& in() const
  {
    return *_ptr;
  }

  T& inout()
  {
    return *_ptr;
  }

  T*& out()
  {
    free();
    return _ptr;
  }

  T& _for_demarshal()
  {
    free();
    return *_ptr;
  }

  T* _retn()
  {
    T *_p = _ptr;
    _ptr = __null;
    return _p;
  }
};

template<class T>
inline void
TVarVar<T>::free()
{
    if( _ptr )
        delete _ptr;
    _ptr = __null;
}





template<class T>
class TVarOut
{
private:
    T*& _ptr;

public:
    TVarOut (T*& p)
        : _ptr (p)
        {
            _ptr = __null;
        }
    TVarOut (TVarVar<T>& p)
        : _ptr (p._ptr)
        {
            delete _ptr;
            _ptr = __null;
        }
    TVarOut (const TVarOut<T>& p)
        : _ptr (p._ptr)
        {
        }
    TVarOut<T>& operator= (const TVarOut<T>& p)
        {
            _ptr = p._ptr;
            return *this;
        }
    TVarOut<T>& operator= (T* p)
        {
            _ptr = p;
            return *this;
        }
    operator T& ()
        {
            return *_ptr;
        }
    operator T*& ()
        {
            return _ptr;
        }
    T*& ptr ()
        {
            return _ptr;
        }
    T* operator-> ()
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 672, __PRETTY_FUNCTION__), 0)));
            return _ptr;
        }

private:
    void operator= (const TVarVar<T>&);
};
# 688 "../include/mico/template.h"
template <class T> class TSeqOut;

template<class T>
class TSeqVar
{

    friend class TSeqOut<T>;

private:
  T* _ptr;

  void free();
  void reset( T* ptr )
  {
    free();
    _ptr = ptr;
  }
public:
  TSeqVar()
  {
    _ptr = __null;
  }
  TSeqVar( T* ptr )
  {
    _ptr = ptr;
  }
  TSeqVar( const TSeqVar<T>& var )
  {
    if (!var._ptr)
      _ptr = __null;
    else
      _ptr = new T (*var._ptr);
  }
  ~TSeqVar()
  {
    free();
  }
  TSeqVar<T>& operator=( T* ptr )
  {
    if (_ptr != ptr)
      reset( ptr );
    return *this;
  }
  TSeqVar<T>& operator=( const TSeqVar<T>& var )
  {
    if (this != &var) {
      free();
      if (!var._ptr)
        _ptr = __null;
      else
        _ptr = new T (*var._ptr);
    }
    return *this;
  }
# 754 "../include/mico/template.h"
  operator T&() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 756, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }

  operator T*()
  {
    return _ptr;
  }
  T* operator->() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 766, __PRETTY_FUNCTION__), 0)));
    return _ptr;
  }
  T& operator*() const
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 771, __PRETTY_FUNCTION__), 0)));
    return *_ptr;
  }

  typename T::ElementType operator[] (MICO_ULong idx)
  {
    ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 777, __PRETTY_FUNCTION__), 0)));
    return (*_ptr)[ idx ];
  }

  const T& in() const
  {
    return *_ptr;
  }

  T& inout()
  {
    return *_ptr;
  }

  T*& out()
  {
    free();
    return _ptr;
  }

  T& _for_demarshal()
  {
    free();
    return *_ptr;
  }

  T* _retn()
  {
    T *_p = _ptr;
    _ptr = __null;
    return _p;
  }
};

template<class T>
inline void
TSeqVar<T>::free()
{
    if( _ptr )
        delete _ptr;
    _ptr = __null;
}





template<class T>
class TSeqOut
{
private:
    T*& _ptr;

public:
    TSeqOut (T*& p)
        : _ptr (p)
        {
            _ptr = __null;
        }
    TSeqOut (TSeqVar<T>& p)
        : _ptr (p._ptr)
        {
            delete _ptr;
            _ptr = __null;
        }
    TSeqOut (const TSeqOut<T>& p)
        : _ptr (p._ptr)
        {
        }
    typename T::ElementType operator[] (MICO_ULong idx)
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 848, __PRETTY_FUNCTION__), 0)));
            return (*_ptr)[ idx ];
        }

    TSeqOut<T>& operator= (const TSeqOut<T>& p)
        {
            _ptr = p._ptr;
            return *this;
        }
    TSeqOut<T>& operator= (T* p)
        {
            _ptr = p;
            return *this;
        }
    operator T& ()
        {
            return *_ptr;
        }
    operator T*& ()
        {
            return _ptr;
        }
    T* operator-> ()
        {
            ((void) ((_ptr) ? 0 : (__assert_fail ("_ptr", "../include/mico/template.h", 872, __PRETTY_FUNCTION__), 0)));
            return _ptr;
        }
    T*& ptr ()
        {
            return _ptr;
        }

private:
    void operator= (const TSeqVar<T>&);
};
# 159 "../include/CORBA.h" 2
# 1 "../include/mico/fixed.h" 1
# 34 "../include/mico/fixed.h"
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/iostream.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/exception" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/char_traits.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_string_fwd.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_climits.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_string.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 2 3


# 1 "/usr/include/ctype.h" 1 3 4
# 26 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/ctype.h" 2 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/ctype.h" 2 3 4

extern "C" {
# 40 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 41 "/usr/include/ctype.h" 2 3 4






enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 75 "/usr/include/ctype.h" 3 4
extern __const unsigned short int *__ctype_b;
extern __const __int32_t *__ctype_tolower;
extern __const __int32_t *__ctype_toupper;
# 91 "/usr/include/ctype.h" 3 4
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();


extern int isblank (int) throw ();




extern int tolower (int __c) throw ();


extern int toupper (int __c) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();






extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 213 "/usr/include/ctype.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 214 "/usr/include/ctype.h" 2 3 4
# 229 "/usr/include/ctype.h" 3 4
extern int __isalnum_l (int, __locale_t) throw ();
extern int __isalpha_l (int, __locale_t) throw ();
extern int __iscntrl_l (int, __locale_t) throw ();
extern int __isdigit_l (int, __locale_t) throw ();
extern int __islower_l (int, __locale_t) throw ();
extern int __isgraph_l (int, __locale_t) throw ();
extern int __isprint_l (int, __locale_t) throw ();
extern int __ispunct_l (int, __locale_t) throw ();
extern int __isspace_l (int, __locale_t) throw ();
extern int __isupper_l (int, __locale_t) throw ();
extern int __isxdigit_l (int, __locale_t) throw ();

extern int __isblank_l (int, __locale_t) throw ();



extern int __tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
# 275 "/usr/include/ctype.h" 3 4
}
# 43 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 2 3
# 60 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 3
namespace std
{
  extern "C" int isalnum(int __c);
  extern "C" int isalpha(int __c);
  extern "C" int isblank(int __c);
  extern "C" int iscntrl(int __c);
  extern "C" int isdigit(int __c);
  extern "C" int isgraph(int __c);
  extern "C" int islower(int __c);
  extern "C" int isprint(int __c);
  extern "C" int ispunct(int __c);
  extern "C" int isspace(int __c);
  extern "C" int isupper(int __c);
  extern "C" int isxdigit(int __c);
  extern "C" int tolower(int __c);
  extern "C" int toupper(int __c);
}
# 41 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 2 3

namespace std
{




  template<unsigned int _Num, int _Shift = (sizeof(unsigned) * 8)/2,
           unsigned int _Mask = (~0u >> _Shift) >
    struct _Count_ones;



  template<unsigned int _Num, unsigned int _Mask>
    struct _Count_ones<_Num, 0, _Mask>
    {
      enum
      {
        _M_count = _Num
      };
    };

  template<unsigned int _Num, int _Shift, unsigned int _Mask>
    struct _Count_ones
    {
      enum
      {
        _M_halfcount = _Count_ones<_Num, _Shift/2,
                                   (_Mask^((~_Mask)>>(_Shift/2))) >::_M_count,
        _M_count = (_M_halfcount&_Mask) + ((_M_halfcount>>_Shift)&_Mask)
      };
    };


  template<typename _Tp> class allocator;
  template<typename _Tp, typename _Alloc> class vector;
  class locale;


  template<typename _CharT>
    inline bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isgraph(_CharT, const locale&);

  template<typename _CharT>
    inline _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    inline _CharT
    tolower(_CharT, const locale&);



  class ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;



  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;


  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;


  template<typename _CharT>
    class collate;
  template<> class collate<char>;



  template<typename _CharT> class
    collate_byname;


  class time_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;


  class messages_base;
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;



  class locale
  {
  public:

    typedef unsigned int category;


    class facet;
    class id;
    class _Impl;

    friend class _Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();



    static const category none = 0;
    static const category ctype = 1 << 0;
    static const category numeric = 1 << 1;
    static const category collate = 1 << 2;
    static const category time = 1 << 3;
    static const category monetary = 1 << 4;
    static const category messages = 1 << 5;
    static const category all = (collate | ctype | monetary |
                                           numeric | time | messages);


    inline
    locale() throw();

    inline
    locale(const locale& __other) throw();

    explicit
    locale(const char* __std_name);

    locale(const locale& __other, const char* __std_name, category __cat);

    locale(const locale& __other, const locale& __one, category __cat);

    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);

    inline
    ~locale() throw();

    const locale&
    operator=(const locale& __other) throw();

    template<typename _Facet>
      locale
      combine(const locale& __other);


    string
    name() const;

    bool
    operator==(const locale& __other) const throw ();

    inline bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }

    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
                 const basic_string<_Char, _Traits, _Alloc>& __s2) const;


    static locale
    global(const locale&);

    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;

    static const int _S_categories_num = _Count_ones<all>::_M_count;
    static const int _S_facets_num = 26;

    explicit
    locale(_Impl*) throw();

    static inline void
    _S_initialize()
    { if (!_S_classic) classic(); }

    static int
    _S_normalize_category(int);
  };



  class locale::_Impl
  {
  public:

    typedef vector<facet*, allocator<facet*> > __vec_facet;
    typedef vector<string, allocator<string> > __vec_string;


    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

  private:

    size_t _M_references;
    __vec_facet* _M_facets;
    __vec_string* _M_category_names;
    bool _M_has_name;
    string _M_name;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    inline void
    _M_add_reference() throw()
    { ++_M_references; }

    inline void
    _M_remove_reference() throw()
    {
      if (_M_references-- == 0)
        {
          try {
            delete this;
          }
          catch(...) {
          }
        }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const _Impl&, const string&, category, size_t);
    _Impl(size_t, size_t, bool __has_name = false, string __name = "*");
   ~_Impl() throw();

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, facet*);

    template<typename _Facet>
      inline void
      _M_facet_init(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    void
    _M_construct_collate(const char*);

    void
    _M_construct_ctype(const char*);

    void
    _M_construct_monetary(const char*);

    void
    _M_construct_numeric(const char*);

    void
    _M_construct_time(const char*);

    void
    _M_construct_messages(const char*);

    category
    _M_normalize_category_names(const string&, category __cat);
  };


  locale::locale() throw()
  {
    _S_initialize();
    (_M_impl = _S_global)->_M_add_reference();
  }

  locale::locale(const locale& __other) throw()
  { (_M_impl = __other._M_impl)->_M_add_reference(); }

  template<typename _Facet>
    locale::locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);
      _M_impl->_M_install_facet(&_Facet::id, __f);
      _M_impl->_M_has_name = false;
      _M_impl->_M_name = "*";
    }

  locale::~locale() throw()
  { _M_impl->_M_remove_reference(); }


  class locale::facet
  {
    friend class locale;
    friend class locale::_Impl;

  protected:
    explicit
    facet(size_t __refs = 0) throw();

    virtual
    ~facet() { };

  private:
    size_t _M_references;

    void
    _M_add_reference() throw();

    void
    _M_remove_reference() throw();

    facet(const facet&);

    void
    operator=(const facet&);
  };



  class locale::id
  {
    friend class locale;
    friend class locale::_Impl;
    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);
    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw ();
  public:
    id() { };
  private:



    mutable size_t _M_index;


    static size_t _S_highwater;

    void
    operator=(const id&);

    id(const id&);
  };

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();

}
# 43 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/ios_base.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/ios_base.h" 3
namespace std {





  enum _Ios_Fmtflags { _M_ios_fmtflags_end = 1 << 16 };

  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Fmtflags
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a | __b; }

  inline _Ios_Fmtflags
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a & __b; }

  inline _Ios_Fmtflags
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a ^ __b; }

  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a)
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }


  enum _Ios_Openmode { _M_ios_openmode_end = 1 << 16 };

  inline _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Openmode
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a | __b; }

  inline _Ios_Openmode
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a & __b; }

  inline _Ios_Openmode
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a ^ __b; }

  inline _Ios_Openmode
  operator~(_Ios_Openmode __a)
  { return _Ios_Openmode(~static_cast<int>(__a)); }


  enum _Ios_Iostate { _M_ios_iostate_end = 1 << 16 };

  inline _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  inline _Ios_Iostate
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a | __b; }

  inline _Ios_Iostate
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a & __b; }

  inline _Ios_Iostate
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a ^ __b; }

  inline _Ios_Iostate
  operator~(_Ios_Iostate __a)
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  enum _Ios_Seekdir { _M_ios_seekdir_end = 1 << 16 };


  class ios_base
  {
  public:


    class failure : public exception
    {
    public:


      explicit
      failure(const string& __str) throw();

      virtual
      ~failure() throw();

      virtual const char*
      what() const throw();

    private:
      enum { _M_bufsize = 256 };
      char _M_name[_M_bufsize];

    };


    typedef _Ios_Fmtflags fmtflags;

    static const fmtflags boolalpha = fmtflags(__ios_flags::_S_boolalpha);
    static const fmtflags dec = fmtflags(__ios_flags::_S_dec);
    static const fmtflags fixed = fmtflags(__ios_flags::_S_fixed);
    static const fmtflags hex = fmtflags(__ios_flags::_S_hex);
    static const fmtflags internal = fmtflags(__ios_flags::_S_internal);
    static const fmtflags left = fmtflags(__ios_flags::_S_left);
    static const fmtflags oct = fmtflags(__ios_flags::_S_oct);
    static const fmtflags right = fmtflags(__ios_flags::_S_right);
    static const fmtflags scientific = fmtflags(__ios_flags::_S_scientific);
    static const fmtflags showbase = fmtflags(__ios_flags::_S_showbase);
    static const fmtflags showpoint = fmtflags(__ios_flags::_S_showpoint);
    static const fmtflags showpos = fmtflags(__ios_flags::_S_showpos);
    static const fmtflags skipws = fmtflags(__ios_flags::_S_skipws);
    static const fmtflags unitbuf = fmtflags(__ios_flags::_S_unitbuf);
    static const fmtflags uppercase = fmtflags(__ios_flags::_S_uppercase);
    static const fmtflags adjustfield = fmtflags(__ios_flags::_S_adjustfield);
    static const fmtflags basefield = fmtflags(__ios_flags::_S_basefield);
    static const fmtflags floatfield = fmtflags(__ios_flags::_S_floatfield);


    typedef _Ios_Iostate iostate;
    static const iostate badbit = iostate(__ios_flags::_S_badbit);
    static const iostate eofbit = iostate(__ios_flags::_S_eofbit);
    static const iostate failbit = iostate(__ios_flags::_S_failbit);
    static const iostate goodbit = iostate(0);


    typedef _Ios_Openmode openmode;
    static const openmode app = openmode(__ios_flags::_S_app);
    static const openmode ate = openmode(__ios_flags::_S_ate);
    static const openmode binary = openmode(__ios_flags::_S_bin);
    static const openmode in = openmode(__ios_flags::_S_in);
    static const openmode out = openmode(__ios_flags::_S_out);
    static const openmode trunc = openmode(__ios_flags::_S_trunc);


    typedef _Ios_Seekdir seekdir;
    static const seekdir beg = seekdir(0);
    static const seekdir cur = seekdir(1);
    static const seekdir end = seekdir(2);
# 214 "/opt/gcc3/include/g++-v3/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };

    typedef void (*event_callback) (event, ios_base&, int);

    void
    register_callback(event_callback __fn, int __index);

  protected:

    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;



    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      int _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
                     _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { ++_M_refcount; }

      int
      _M_remove_reference() { return _M_refcount--; }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void);


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
    };

    static const int _S_local_words = 8;
    _Words _M_word_array[_S_local_words];
    _Words _M_dummy;
    _Words* _M_words;
    int _M_word_limit;

    _Words&
    _M_grow_words(int __index);


    locale _M_ios_locale;

    void
    _M_init();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();
    private:
      static int _S_ios_base_init;
      static bool _S_synced_with_stdio;
      filebuf* _M_cout;
      filebuf* _M_cin;
      filebuf* _M_cerr;





    };


    inline fmtflags
    flags() const { return _M_flags; }

    inline fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }

    inline fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }

    inline fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }

    inline void
    unsetf(fmtflags __mask) { _M_flags &= ~__mask; }

    inline streamsize
    precision() const { return _M_precision; }

    inline streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }

    inline streamsize
    width() const { return _M_width; }

    inline streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }

    static bool
    sync_with_stdio(bool __sync = true);


    locale
    imbue(const locale& __loc);

    inline locale
    getloc() const { return _M_ios_locale; }


    static int
    xalloc() throw();

    inline long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_limit)
                        ? _M_words[__ix] : _M_grow_words(__ix);
      return __word._M_iword;
    }

    inline void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_limit)
                        ? _M_words[__ix] : _M_grow_words(__ix);
      return __word._M_pword;
    }


    ~ios_base();

  protected:
    ios_base();


  private:
    ios_base(const ios_base&);

    ios_base&
    operator=(const ios_base&);

  };


  inline ios_base&
  boolalpha(ios_base& __base)
  {
    __base.setf(ios_base::boolalpha);
    return __base;
  }

  inline ios_base&
  noboolalpha(ios_base& __base)
  {
    __base.unsetf(ios_base::boolalpha);
    return __base;
  }

  inline ios_base&
  showbase(ios_base& __base)
  {
    __base.setf(ios_base::showbase);
    return __base;
  }

  inline ios_base&
  noshowbase(ios_base& __base)
  {
    __base.unsetf(ios_base::showbase);
    return __base;
  }

  inline ios_base&
  showpoint(ios_base& __base)
  {
    __base.setf(ios_base::showpoint);
    return __base;
  }

  inline ios_base&
  noshowpoint(ios_base& __base)
  {
    __base.unsetf(ios_base::showpoint);
    return __base;
  }

  inline ios_base&
  showpos(ios_base& __base)
  {
    __base.setf(ios_base::showpos);
    return __base;
  }

  inline ios_base&
  noshowpos(ios_base& __base)
  {
    __base.unsetf(ios_base::showpos);
    return __base;
  }

  inline ios_base&
  skipws(ios_base& __base)
  {
    __base.setf(ios_base::skipws);
    return __base;
  }

  inline ios_base&
  noskipws(ios_base& __base)
  {
    __base.unsetf(ios_base::skipws);
    return __base;
  }

  inline ios_base&
  uppercase(ios_base& __base)
  {
    __base.setf(ios_base::uppercase);
    return __base;
  }

  inline ios_base&
  nouppercase(ios_base& __base)
  {
    __base.unsetf(ios_base::uppercase);
    return __base;
  }

  inline ios_base&
  unitbuf(ios_base& __base)
  {
     __base.setf(ios_base::unitbuf);
     return __base;
  }

  inline ios_base&
  nounitbuf(ios_base& __base)
  {
     __base.unsetf(ios_base::unitbuf);
     return __base;
  }


  inline ios_base&
  internal(ios_base& __base)
  {
     __base.setf(ios_base::internal, ios_base::adjustfield);
     return __base;
  }

  inline ios_base&
  left(ios_base& __base)
  {
    __base.setf(ios_base::left, ios_base::adjustfield);
    return __base;
  }

  inline ios_base&
  right(ios_base& __base)
  {
    __base.setf(ios_base::right, ios_base::adjustfield);
    return __base;
  }


  inline ios_base&
  dec(ios_base& __base)
  {
    __base.setf(ios_base::dec, ios_base::basefield);
    return __base;
  }

  inline ios_base&
  hex(ios_base& __base)
  {
    __base.setf(ios_base::hex, ios_base::basefield);
    return __base;
  }

  inline ios_base&
  oct(ios_base& __base)
  {
    __base.setf(ios_base::oct, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  fixed(ios_base& __base)
  {
    __base.setf(ios_base::fixed, ios_base::floatfield);
    return __base;
  }

  inline ios_base&
  scientific(ios_base& __base)
  {
    __base.setf(ios_base::scientific, ios_base::floatfield);
    return __base;
  }

}
# 44 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdio.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/ios_base.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 2 3

namespace std {

  template<typename _CharT, typename _Traits>
    static streamsize
    _S_copy_streambufs(basic_ios<_CharT, _Traits>& _ios,
                       basic_streambuf<_CharT, _Traits>* __sbin,
                       basic_streambuf<_CharT, _Traits>* __sbout);


  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef ctype<char_type> __ctype_type;
      typedef basic_streambuf<char_type, traits_type> __streambuf_type;

      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      _S_copy_streambufs<>(basic_ios<char_type, traits_type>& __ios,
                           __streambuf_type* __sbin,__streambuf_type* __sbout);

    protected:






      char_type* _M_buf;


      int_type _M_buf_size;


      int_type _M_buf_size_opt;



      bool _M_buf_unified;






      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      ios_base::openmode _M_mode;


      locale _M_buf_locale;


      bool _M_buf_locale_init;


      const __ctype_type* _M_buf_fctype;






      int_type _M_pback_size;
      char_type* _M_pback;
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;




      void
      _M_pback_create()
      {
        if (!_M_pback_init)
          {
            int_type __dist = _M_in_end - _M_in_cur;
            int_type __len = min(_M_pback_size, __dist);
            traits_type::copy(_M_pback, _M_in_cur, __len);
            _M_pback_cur_save = _M_in_cur;
            _M_pback_end_save = _M_in_end;
            this->setg(_M_pback, _M_pback, _M_pback + __len);
            _M_pback_init = true;
          }
      }




      void
      _M_pback_destroy()
      {
        if (_M_pback_init)
          {

            int_type __off_cur = _M_in_cur - _M_pback;


            int_type __off_end = 0;
            int_type __pback_len = _M_in_end - _M_pback;
            int_type __save_len = _M_pback_end_save - _M_buf;
            if (__pback_len > __save_len)
              __off_end = __pback_len - __save_len;

            this->setg(_M_buf, _M_pback_cur_save + __off_cur,
                       _M_pback_end_save + __off_end);
            _M_pback_cur_save = __null;
            _M_pback_end_save = __null;
            _M_pback_init = false;
          }
      }



      void
      _M_in_cur_move(off_type __n)
      {
        bool __testout = _M_out_cur;
        _M_in_cur += __n;
        if (__testout && _M_buf_unified)
          _M_out_cur += __n;
      }
# 194 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 3
      void
      _M_out_cur_move(off_type __n)
      {
        bool __testin = _M_in_cur;

        _M_out_cur += __n;
        if (__testin && _M_buf_unified)
          _M_in_cur += __n;
        if (_M_out_cur > _M_out_end)
          {
            _M_out_end = _M_out_cur;

            if (__testin)
              _M_in_end += __n;
          }
      }




      off_type
      _M_out_buf_size()
      {
        off_type __ret = 0;
        if (_M_out_cur)
          {

            if (_M_out_beg == _M_buf)
              __ret = _M_out_beg + _M_buf_size - _M_out_cur;

            else
              __ret = _M_out_end - _M_out_cur;
          }
        return __ret;
      }
# 237 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 3
      void
      _M_set_indeterminate(void)
      {
        if (_M_mode & ios_base::in)
          this->setg(_M_buf, _M_buf, _M_buf);
        if (_M_mode & ios_base::out)
          this->setp(_M_buf, _M_buf);
      }

      void
      _M_set_determinate(off_type __off)
      {
        bool __testin = _M_mode & ios_base::in;
        bool __testout = _M_mode & ios_base::out;
        if (__testin)
          this->setg(_M_buf, _M_buf, _M_buf + __off);
        if (__testout)
          this->setp(_M_buf, _M_buf + __off);

      }

      bool
      _M_is_indeterminate(void)
      {
        bool __ret = false;
        if (_M_mode & ios_base::in)
          __ret = _M_in_beg == _M_in_cur && _M_in_cur == _M_in_end;
        if (_M_mode & ios_base::out)
          __ret = _M_out_beg == _M_out_cur && _M_out_cur == _M_out_end;
        return __ret;
      }

  public:
      virtual
      ~basic_streambuf()
      {
        _M_buf_unified = false;
        _M_buf_size = 0;
        _M_buf_size_opt = 0;
        _M_mode = ios_base::openmode(0);
        _M_buf_fctype = __null;
        _M_buf_locale_init = false;

      }


      locale
      pubimbue(const locale &__loc)
      {
        locale __tmp(this->getloc());
        this->imbue(__loc);
        return __tmp;
      }

      locale
      getloc() const
      {
        if (_M_buf_locale_init)
          return _M_buf_locale;
        else
          return locale();
      }


      __streambuf_type*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }

      pos_type
      pubseekoff(off_type __off, ios_base::seekdir __way,
                 ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }

      pos_type
      pubseekpos(pos_type __sp,
                 ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }

      int
      pubsync() { return this->sync(); }



      streamsize
      in_avail()
      {
        streamsize __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          {
            if (_M_pback_init)
              {
                int_type __save_len = _M_pback_end_save - _M_pback_cur_save;
                int_type __pback_len = _M_in_cur - _M_pback;
                __ret = __save_len - __pback_len;
              }
            else
              __ret = this->egptr() - this->gptr();
          }
        else
          __ret = this->showmanyc();
        return __ret;
      }

      int_type
      snextc()
      {
        int_type __eof = traits_type::eof();
        return (this->sbumpc() == __eof ? __eof : this->sgetc());
      }

      int_type
      sbumpc();

      int_type
      sgetc()
      {
        int_type __ret;
        if (_M_in_cur && _M_in_cur < _M_in_end)
          __ret = traits_type::to_int_type(*gptr());
        else
          __ret = this->underflow();
        return __ret;
      }

      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }


      int_type
      sputbackc(char_type __c);

      int_type
      sungetc();


      int_type
      sputc(char_type __c);

      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
      basic_streambuf()
      : _M_buf(__null), _M_buf_size(0),
      _M_buf_size_opt(static_cast<int_type>(8192)), _M_buf_unified(false),
      _M_in_beg(0), _M_in_cur(0), _M_in_end(0), _M_out_beg(0), _M_out_cur(0),
      _M_out_end(0), _M_mode(ios_base::openmode(0)), _M_buf_locale(locale()),
      _M_buf_locale_init(false), _M_pback_size(1), _M_pback(__null),
      _M_pback_cur_save(__null), _M_pback_end_save(__null), _M_pback_init(false)
      { _M_buf_fctype = &use_facet<__ctype_type>(this->getloc()); }


      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }

      void
      gbump(int __n) { _M_in_cur += __n; }

      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
        _M_in_beg = __gbeg;
        _M_in_cur = __gnext;
        _M_in_end = __gend;
        if (!(_M_mode & ios_base::in) && __gbeg && __gnext && __gend)
          _M_mode = _M_mode | ios_base::in;
      }


      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }

      void
      pbump(int __n) { _M_out_cur += __n; }

      void
      setp(char_type* __pbeg, char_type* __pend)
      {
        _M_out_beg = _M_out_cur = __pbeg;
        _M_out_end = __pend;
        if (!(_M_mode & ios_base::out) && __pbeg && __pend)
          _M_mode = _M_mode | ios_base::out;
      }



      virtual void
      imbue(const locale& __loc)
      {
        _M_buf_locale_init = true;
        if (_M_buf_locale != __loc)
         {
           _M_buf_locale = __loc;
           _M_buf_fctype = &use_facet<__ctype_type>(_M_buf_locale);
         }
      }


      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }

      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
              ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }

      virtual pos_type
      seekpos(pos_type,
              ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }

      virtual int
      sync() { return 0; }


      virtual streamsize
      showmanyc() { return 0; }

      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);

      virtual int_type
      underflow()
      { return traits_type::eof(); }

      virtual int_type
      uflow()
      {
        int_type __ret = traits_type::eof();
        bool __testeof = this->underflow() == __ret;
        bool __testpending = _M_in_cur && _M_in_cur < _M_in_end;
        if (!__testeof && __testpending)
          {
            __ret = traits_type::to_int_type(*_M_in_cur);
            ++_M_in_cur;
            if (_M_buf_unified && _M_mode & ios_base::out)
              ++_M_out_cur;
          }
        return __ret;
      }


      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }


      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);

      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 519 "/opt/gcc3/include/g++-v3/bits/std_streambuf.h" 3
    private:
      basic_streambuf(const __streambuf_type&);

      __streambuf_type&
      operator=(const __streambuf_type&);

    };

}
# 45 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/basic_ios.h" 1 3
# 33 "/opt/gcc3/include/g++-v3/bits/basic_ios.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/sbuf_iter.h" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/sbuf_iter.h" 3
namespace std
{

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator



    : public output_iterator

    {
    public:


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;

      inline
      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(false) { }

      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(false) { }

      ostreambuf_iterator&
      operator=(_CharT __c);

      ostreambuf_iterator&
      operator*() throw()
      { return *this; }

      ostreambuf_iterator&
      operator++(int) throw()
      { return *this; }

      ostreambuf_iterator&
      operator++() throw()
      { return *this; }

      bool
      failed() const throw()
      { return _M_failed; }

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;
# 94 "/opt/gcc3/include/g++-v3/bits/sbuf_iter.h" 3
    };

  template<typename _CharT, typename _Traits>
    inline ostreambuf_iterator<_CharT, _Traits>&
    ostreambuf_iterator<_CharT, _Traits>::operator=(_CharT __c)
    {
      if (!_M_failed &&
          _Traits::eq_int_type(_M_sbuf->sputc(__c),_Traits::eof()))
      _M_failed = true;
      return *this;
    }
# 135 "/opt/gcc3/include/g++-v3/bits/sbuf_iter.h" 3
  template<class _CharT, class _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
                      _CharT*, _CharT&>
    {
    public:


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

      typedef istreambuf_iterator<_CharT, _Traits> __istreambufiter_type;

      istreambuf_iterator() throw()
      : _M_istreambuf(__null), _M_c(-2) { }

      istreambuf_iterator(istream_type& __s) throw()
      : _M_istreambuf(__s.rdbuf()), _M_c(-2) { }

      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_istreambuf(__s), _M_c(-2) { }




      char_type
      operator*() const
      {

        char_type __ret;
        if (_M_istreambuf && _M_c != static_cast<int_type>(-2))
          __ret = _M_c;
        else if (_M_istreambuf)
          __ret = traits_type::to_char_type(_M_istreambuf->sgetc());
        else
          __ret = static_cast<char_type>(traits_type::eof());
        return __ret;
      }

      __istreambufiter_type&
      operator++()
      {
        if (_M_istreambuf)
          _M_istreambuf->sbumpc();
        _M_c = -2;
        return *this;
      }





      const __istreambufiter_type
      operator++(int)
      {
        if (_M_istreambuf)
          _M_c = _M_istreambuf->sbumpc();
        return *this;
      }


      bool
      equal(const __istreambufiter_type& __b)
      {
        int_type __eof = traits_type::eof();
        bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
        bool __beof = !__b._M_istreambuf
                      || __b._M_istreambuf->sgetc() == __eof;
        return (__thiseof && __beof || (!__thiseof && !__beof));
      }




      bool
      equal(const __istreambufiter_type& __b) const
      {
        int_type __eof = traits_type::eof();
        bool __thiseof = !_M_istreambuf || _M_istreambuf->sgetc() == __eof;
        bool __beof = !__b._M_istreambuf
                      || __b._M_istreambuf->sgetc() == __eof;
        return (__thiseof && __beof || (!__thiseof && !__beof));
      }


    private:







      streambuf_type* _M_istreambuf;
      int_type _M_c;
    };

  template<typename _CharT, typename _Traits>
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }

  template<typename _CharT, typename _Traits>
    inline bool
    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
               const istreambuf_iterator<_CharT, _Traits>& __b)
    { return !__a.equal(__b); }

}
# 34 "/opt/gcc3/include/g++-v3/bits/basic_ios.h" 2 3

namespace std {


  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {
    public:


      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef ctype<_CharT> __ctype_type;

      typedef ostreambuf_iterator<_CharT> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef istreambuf_iterator<_CharT> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;


    private:
      basic_ostream<_CharT, _Traits>* _M_tie;
      char_type _M_fill;
      iostate _M_exception;

    protected:
      basic_streambuf<_CharT, _Traits>* _M_streambuf;
      iostate _M_streambuf_state;


      const __ctype_type* _M_ios_fctype;

      const __numput_type* _M_fnumput;

      const __numget_type* _M_fnumget;

    public:

      inline const __ctype_type*
      _M_get_fctype_ios(void)
      { return _M_ios_fctype; }

      inline const __numget_type*
      _M_get_fnumget(void)
      { return _M_fnumget; }

      inline const __numput_type*
      _M_get_fnumput(void)
      { return _M_fnumput; }

      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      inline bool
      operator!() const
      { return this->fail(); }

      inline iostate
      rdstate() const
      { return _M_streambuf_state; }

      inline void
      clear(iostate __state = goodbit)
      {
        if (this->rdbuf())
          _M_streambuf_state = __state;
        else
          _M_streambuf_state = __state | badbit;
        if ((this->rdstate() & this->exceptions()))
          throw failure("basic_ios::clear(iostate) caused exception");
      }

      inline void
      setstate(iostate __state)
      { this->clear(this->rdstate() | __state); }

      inline bool
      good() const
      { return this->rdstate() == 0; }

      inline bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }

      inline bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }

      inline bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }

      inline iostate
      exceptions() const
      { return _M_exception; }

      inline void
      exceptions(iostate __except)
      {
        _M_exception = __except;
        this->clear(_M_streambuf_state);
      }


      explicit
      basic_ios(basic_streambuf<_CharT, _Traits>* __sb) : ios_base()
      { this->init(__sb); }

      virtual
      ~basic_ios() { }


      inline basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }

      inline basic_ostream<_CharT, _Traits>*
      tie(basic_ostream<_CharT, _Traits>* __tiestr)
      {
        basic_ostream<_CharT, _Traits>* __old = _M_tie;
        _M_tie = __tiestr;
        return __old;
      }

      inline basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }

      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);

      basic_ios&
      copyfmt(const basic_ios& __rhs);

      inline char_type
      fill() const
      { return _M_fill; }

      inline char_type
      fill(char_type __ch)
      {
        char_type __old = _M_fill;
        _M_fill = __ch;
        return __old;
      }


      locale
      imbue(const locale& __loc);

      char
      narrow(char_type __c, char __dfault) const;

      char_type
      widen(char __c) const;

    protected:

      basic_ios() : ios_base()
      { }

      void
      init(basic_streambuf<_CharT, _Traits>* __sb);
    };

}
# 46 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 2 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 2 3

namespace std {


  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:


      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef ostreambuf_iterator<_CharT> __ostreambuf_iter;
      typedef num_put<_CharT, __ostreambuf_iter> __numput_type;
      typedef ctype<_CharT> __ctype_type;


      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }

      virtual
      ~basic_ostream()
      { _M_fnumput = __null; }


      class sentry;
      friend class sentry;



      __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&));

      __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&));

      __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&));


      __ostream_type&
      operator<<(long __n);

      __ostream_type&
      operator<<(unsigned long __n);

      __ostream_type&
      operator<<(bool __n);

      __ostream_type&
      operator<<(short __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned short>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned short __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }

      __ostream_type&
      operator<<(int __n)
      {
        ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
        if (__fmt & ios_base::oct || __fmt & ios_base::hex)
          return this->operator<<(static_cast<unsigned long>
                                  (static_cast<unsigned int>(__n)));
        else
          return this->operator<<(static_cast<long>(__n));
      }

      __ostream_type&
      operator<<(unsigned int __n)
      { return this->operator<<(static_cast<unsigned long>(__n)); }
# 134 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 3
      __ostream_type&
      operator<<(double __f);

      __ostream_type&
      operator<<(float __f)
      { return this->operator<<(static_cast<double>(__f)); }

      __ostream_type&
      operator<<(long double __f);

      __ostream_type&
      operator<<(const void* __p);

      __ostream_type&
      operator<<(__streambuf_type* __sb);


      __ostream_type&
      put(char_type __c);

      __ostream_type&
      write(const char_type* __s, streamsize __n);

      __ostream_type&
      flush();


      pos_type
      tellp();

      __ostream_type&
      seekp(pos_type);

      __ostream_type&
      seekp(off_type, ios_base::seekdir);

    private:


      __ostream_type&
      operator=(const __ostream_type&);

      basic_ostream(const __ostream_type&);

    };


  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT,_Traits>& _M_os;

    public:
      explicit
      sentry(basic_ostream<_CharT,_Traits>& __os);

      ~sentry()
      {

        if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
          {

            if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
              _M_os.setstate(ios_base::badbit);
          }
      }

      operator bool()
      { return _M_ok; }
    };

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_Traits::_S_eos()); }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}
# 39 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 2 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/std_limits.h" 1 3
# 45 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/std_limits.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 46 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/std_limits.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cfloat.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cfloat.h" 3
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/float.h" 1 3 4
# 41 "/opt/gcc3/include/g++-v3/bits/std_cfloat.h" 2 3
# 47 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/std_limits.h" 2 3

namespace std {

    enum float_round_style {
        round_indeterminate = -1,
        round_toward_zero = 0,
        round_to_nearest = 1,
        round_toward_infinity = 2,
        round_toward_neg_infinity = 3
    };

    enum float_denorm_style {
        denorm_indeterminate = -1,
        denorm_absent = 0,
        denorm_present = 1
    };

    template<typename _Tp> struct numeric_limits {
        static const bool is_specialized = false;

        static _Tp min() throw() { return static_cast<_Tp>(0); }
        static _Tp max() throw() { return static_cast<_Tp>(0); }

        static const int digits = 0;
        static const int digits10 = 0;
        static const bool is_signed = false;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 0;

        static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
        static _Tp round_error() throw() { return static_cast<_Tp>(0); }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static _Tp infinity() throw() { return static_cast<_Tp>(0); }
        static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
        static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
        static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = false;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<typename _Tp> _Tp __limits_infinity();
    template<typename _Tp> _Tp __limits_quiet_NaN();
    template<typename _Tp> _Tp __limits_signaling_NaN();
    template<typename _Tp> _Tp __limits_denorm_min();

    template<> struct numeric_limits<bool> {
        static const bool is_specialized = true;

        static bool min() throw()
        { return false; }
        static bool max() throw()
        { return true; }

        static const int digits = 8;
        static const int digits10 = 2;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static bool epsilon() throw()
        { return 0; }
        static bool round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static bool infinity() throw()
        { return static_cast<bool>(0); }
        static bool quiet_NaN() throw()
        { return static_cast<bool>(0); }
        static bool signaling_NaN() throw()
        { return static_cast<bool>(0); }
        static bool denorm_min() throw()
        { return static_cast<bool>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<char> {
        static const bool is_specialized = true;

        static char min() throw()
        { return (-128); }
        static char max() throw()
        { return 127; }

        static const int digits = 7;
        static const int digits10 = 2;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static char epsilon() throw()
        { return 0; }
        static char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static char infinity() throw()
        { return static_cast<char>(0); }
        static char quiet_NaN() throw()
        { return static_cast<char>(0); }
        static char signaling_NaN() throw()
        { return static_cast<char>(0); }
        static char denorm_min() throw()
        { return static_cast<char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<signed char> {
        static const bool is_specialized = true;

        static signed char min() throw()
        { return (-128); }
        static signed char max() throw()
        { return 127; }

        static const int digits = 7;
        static const int digits10 = 2;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static signed char epsilon() throw()
        { return 0; }
        static signed char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static signed char infinity() throw()
        { return static_cast<signed char>(0); }
        static signed char quiet_NaN() throw()
        { return static_cast<signed char>(0); }
        static signed char signaling_NaN() throw()
        { return static_cast<signed char>(0); }
        static signed char denorm_min() throw()
        { return static_cast<signed char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned char> {
        static const bool is_specialized = true;

        static unsigned char min() throw()
        { return 0; }
        static unsigned char max() throw()
        { return 255; }

        static const int digits = 8;
        static const int digits10 = 2;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned char epsilon() throw()
        { return 0; }
        static unsigned char round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned char infinity() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char quiet_NaN() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char signaling_NaN() throw()
        { return static_cast<unsigned char>(0); }
        static unsigned char denorm_min() throw()
        { return static_cast<unsigned char>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<short> {
        static const bool is_specialized = true;

        static short min() throw()
        { return (-32767 -1); }
        static short max() throw()
        { return 32767; }

        static const int digits = 15;
        static const int digits10 = 4;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static short epsilon() throw()
        { return 0; }
        static short round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static short infinity() throw()
        { return static_cast<short>(0); }
        static short quiet_NaN() throw()
        { return static_cast<short>(0); }
        static short signaling_NaN() throw()
        { return static_cast<short>(0); }
        static short denorm_min() throw()
        { return static_cast<short>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned short> {
        static const bool is_specialized = true;

        static unsigned short min() throw()
        { return 0; }
        static unsigned short max() throw()
        { return 65535; }

        static const int digits = 16;
        static const int digits10 = 4;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned short epsilon() throw()
        { return 0; }
        static unsigned short round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned short infinity() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short quiet_NaN() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short signaling_NaN() throw()
        { return static_cast<unsigned short>(0); }
        static unsigned short denorm_min() throw()
        { return static_cast<unsigned short>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<int> {
        static const bool is_specialized = true;

        static int min() throw()
        { return (-2147483647 -1); }
        static int max() throw()
        { return 2147483647; }

        static const int digits = 31;
        static const int digits10 = 9;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static int epsilon() throw()
        { return 0; }
        static int round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static int infinity() throw()
        { return static_cast<int>(0); }
        static int quiet_NaN() throw()
        { return static_cast<int>(0); }
        static int signaling_NaN() throw()
        { return static_cast<int>(0); }
        static int denorm_min() throw()
        { return static_cast<int>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned int> {
        static const bool is_specialized = true;

        static unsigned int min() throw()
        { return 0; }
        static unsigned int max() throw()
        { return (2147483647 * 2U + 1); }

        static const int digits = 32;
        static const int digits10 = 9;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned int epsilon() throw()
        { return 0; }
        static unsigned int round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned int infinity() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int quiet_NaN() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int signaling_NaN() throw()
        { return static_cast<unsigned int>(0); }
        static unsigned int denorm_min() throw()
        { return static_cast<unsigned int>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<long> {
        static const bool is_specialized = true;

        static long min() throw()
        { return (-2147483647L -1); }
        static long max() throw()
        { return 2147483647L; }

        static const int digits = 31;
        static const int digits10 = 9;
        static const bool is_signed = true;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static long epsilon() throw()
        { return 0; }
        static long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static long infinity() throw()
        { return static_cast<long>(0); }
        static long quiet_NaN() throw()
        { return static_cast<long>(0); }
        static long signaling_NaN() throw()
        { return static_cast<long>(0); }
        static long denorm_min() throw()
        { return static_cast<long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<unsigned long> {
        static const bool is_specialized = true;

        static unsigned long min() throw()
        { return 0; }
        static unsigned long max() throw()
        { return (2147483647L * 2UL + 1); }

        static const int digits = 32;
        static const int digits10 = 9;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 2;
        static unsigned long epsilon() throw()
        { return 0; }
        static unsigned long round_error() throw()
        { return 0; }

        static const int min_exponent = 0;
        static const int min_exponent10 = 0;
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static unsigned long infinity() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long quiet_NaN() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long signaling_NaN() throw()
        { return static_cast<unsigned long>(0); }
        static unsigned long denorm_min() throw()
        { return static_cast<unsigned long>(0); }

        static const bool is_iec559 = true;
        static const bool is_bounded = true;
        static const bool is_modulo = true;

        static const bool traps = true;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<float> {
        static const bool is_specialized = true;

        static float min() throw()
        { return 1.17549435e-38F; }
        static float max() throw()
        { return 3.40282347e+38F; }

        static const int digits = 24;
        static const int digits10 = 7;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static float epsilon() throw()
        { return 1.19209290e-07F; }
        static float round_error() throw()
        { return 1.0f; }

        static const int min_exponent = -125;
        static const int min_exponent10 = -37;
        static const int max_exponent = 128;
        static const int max_exponent10 = 38;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static float infinity() throw()
        { return static_cast<float>(0); }
        static float quiet_NaN() throw()
        { return static_cast<float>(0); }
        static float signaling_NaN() throw()
        { return static_cast<float>(0); }
        static float denorm_min() throw()
        { return static_cast<float>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<double> {
        static const bool is_specialized = true;

        static double min() throw()
        { return 2.2250738585072014e-308; }
        static double max() throw()
        { return 1.7976931348623157e+308; }

        static const int digits = 53;
        static const int digits10 = 15;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static double epsilon() throw()
        { return 2.2204460492503131e-16; }
        static double round_error() throw()
        { return 1.0; }

        static const int min_exponent = -1021;
        static const int min_exponent10 = -307;
        static const int max_exponent = 1024;
        static const int max_exponent10 = 308;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static double infinity() throw()
        { return static_cast<double>(0); }
        static double quiet_NaN() throw()
        { return static_cast<double>(0); }
        static double signaling_NaN() throw()
        { return static_cast<double>(0); }
        static double denorm_min() throw()
        { return static_cast<double>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

    template<> struct numeric_limits<long double> {
        static const bool is_specialized = true;

        static long double min() throw()
        { return 3.36210314311209350626e-4932L; }
        static long double max() throw()
        { return 1.18973149535723176502e+4932L; }

        static const int digits = 64;
        static const int digits10 = 19;
        static const bool is_signed = true;
        static const bool is_integer = false;
        static const bool is_exact = false;
        static const int radix = 2;
        static long double epsilon() throw()
        { return 1.08420217248550443401e-19L; }
        static long double round_error() throw()
        { return 1.0L; }

        static const int min_exponent = -16381;
        static const int min_exponent10 = -4931;
        static const int max_exponent = 16384;
        static const int max_exponent10 = 4932;

        static const bool has_infinity = false;
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;

        static long double infinity() throw()
        { return static_cast<long double>(0); }
        static long double quiet_NaN() throw()
        { return static_cast<long double>(0); }
        static long double signaling_NaN() throw()
        { return static_cast<long double>(0); }
        static long double denorm_min() throw()
        { return static_cast<long double>(0); }

        static const bool is_iec559 = false;
        static const bool is_bounded = true;
        static const bool is_modulo = false;

        static const bool traps = false;
        static const bool tinyness_before = false;
        static const float_round_style round_style = round_toward_zero;
    };

}
# 39 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 2 3

namespace std {


  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:


      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef istreambuf_iterator<_CharT> __istreambuf_iter;
      typedef num_get<_CharT, __istreambuf_iter> __numget_type;
      typedef ctype<_CharT> __ctype_type;

    protected:

      streamsize _M_gcount;

    public:

      explicit
      basic_istream(__streambuf_type* __sb)
      {
        this->init(__sb);
        _M_gcount = streamsize(0);
      }

      virtual
      ~basic_istream()
      {
        _M_gcount = streamsize(0);
        _M_fnumget = __null;
      }


      class sentry;
      friend class sentry;



      __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&));

      __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&));

      __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&));


      __istream_type&
      operator>>(bool& __n);

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n);

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n);

      __istream_type&
      operator>>(long& __n);

      __istream_type&
      operator>>(unsigned long& __n);
# 128 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 3
      __istream_type&
      operator>>(float& __f);

      __istream_type&
      operator>>(double& __f);

      __istream_type&
      operator>>(long double& __f);

      __istream_type&
      operator>>(void*& __p);

      __istream_type&
      operator>>(__streambuf_type* __sb);


      inline streamsize
      gcount(void) const
      { return _M_gcount; }

      int_type
      get(void);

      __istream_type&
      get(char_type& __c);

      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);

      inline __istream_type&
      get(char_type* __s, streamsize __n)
      { return get(__s, __n, this->widen('\n')); }

      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);

      inline __istream_type&
      get(__streambuf_type& __sb)
      { return get(__sb, this->widen('\n')); }

      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);

      inline __istream_type&
      getline(char_type* __s, streamsize __n)
      { return getline(__s, __n, this->widen('\n')); }

      __istream_type&
      ignore(streamsize __n = 1, int_type __delim = traits_type::eof());

      int_type
      peek(void);

      __istream_type&
      read(char_type* __s, streamsize __n);

      streamsize
      readsome(char_type* __s, streamsize __n);

      __istream_type&
      putback(char_type __c);

      __istream_type&
      unget(void);

      int
      sync(void);

      pos_type
      tellg(void);

      __istream_type&
      seekg(pos_type);

      __istream_type&
      seekg(off_type, ios_base::seekdir);

    private:


      __istream_type&
      operator=(const __istream_type&);

      basic_istream(const __istream_type&);

    };

  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {
    public:

      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;

      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);

      operator bool() { return _M_ok; }

    private:
      bool _M_ok;
    };


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> static_cast<char>(__c)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> static_cast<char>(__c)); }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    basic_istream<char,_Traits>&
    operator>>(basic_istream<char,_Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }


  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:


      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;

      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb)
      { }

      virtual
      ~basic_iostream() { }
    };


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);

}
# 40 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 2 3

namespace std
{
  extern istream cin;
  extern ostream cout;
  extern ostream cerr;
  extern ostream clog;
# 55 "/opt/gcc3/include/g++-v3/bits/std_iostream.h" 3
  static ios_base::Init __ioinit;
}
# 32 "/opt/gcc3/include/g++-v3/iostream.h" 2 3

using std::iostream;
using std::ostream;
using std::istream;
using std::ios;
using std::streambuf;

using std::cout;
using std::cin;
using std::cerr;
using std::clog;







using std::endl;
using std::ends;
# 35 "../include/mico/fixed.h" 2

class FixedBase {
    MICO_UShort _digits;
    MICO_Short _scale;
    MICO_LongDouble _val;

    void adjust (MICO_Boolean round = 1);
    MICO_LongDouble transform (MICO_Short nscale) const;
public:
    typedef SequenceTmpl<MICO_Octet,3> FixedValue;
    typedef TSeqVar<FixedValue> FixedValue_var;

    FixedBase ();
    FixedBase (MICO_Long);
    FixedBase (MICO_ULong);
    FixedBase (MICO_LongLong);
    FixedBase (MICO_ULongLong);
    FixedBase (MICO_Double);
    FixedBase (MICO_LongDouble);
    FixedBase (const char *);
    FixedBase (MICO_UShort d, MICO_Short s);
    FixedBase (const FixedBase &);
    ~FixedBase ();

    operator MICO_LongDouble () const;
    operator MICO_LongLong () const;
    FixedBase round (MICO_UShort nscale) const;
    FixedBase truncate (MICO_UShort nscale) const;

    FixedBase &operator= (const FixedBase &);
    FixedBase &operator+= (const FixedBase &);
    FixedBase &operator-= (const FixedBase &);
    FixedBase &operator*= (const FixedBase &);
    FixedBase &operator/= (const FixedBase &);

    FixedBase &operator++ ();
    FixedBase operator++ (int);
    FixedBase &operator-- ();
    FixedBase operator-- (int);
    FixedBase operator+ () const;
    FixedBase operator- () const;
    MICO_Boolean operator!() const;

    static void compute_params (const char *str,
                                MICO_UShort &digits, MICO_Short &scale,
                                MICO_UShort max_significant_digits = 1000);





    FixedValue* to_digits () const;
    void from_digits (const FixedValue &);

    istream &read (istream &);
    ostream &write (ostream &) const;

    static void add (FixedBase &res, const FixedBase &a1, const FixedBase a2);
    static void sub (FixedBase &res, const FixedBase &a1, const FixedBase a2);
    static void mul (FixedBase &res, const FixedBase &a1, const FixedBase a2);
    static void div (FixedBase &res, const FixedBase &a1, const FixedBase a2);
    static void neg (FixedBase &res, const FixedBase &a);

    static int eq (const FixedBase &a1, const FixedBase &a2);
    static int lt (const FixedBase &a1, const FixedBase &a2);
    static int le (const FixedBase &a1, const FixedBase &a2);

    MICO_UShort fixed_digits () const
    { return _digits; }

    MICO_Short fixed_scale () const
    { return _scale; }
};

static inline istream&
operator>> (istream &i, FixedBase &f)
{
    return f.read (i);
}

static inline ostream&
operator<< (ostream &o, const FixedBase &f)
{
    return f.write (o);
}

FixedBase operator+ (const FixedBase &v1, const FixedBase &v2);
FixedBase operator- (const FixedBase &v1, const FixedBase &v2);
FixedBase operator* (const FixedBase &v1, const FixedBase &v2);
FixedBase operator/ (const FixedBase &v1, const FixedBase &v2);

MICO_Boolean operator> (const FixedBase &v1, const FixedBase &v2);
MICO_Boolean operator< (const FixedBase &v1, const FixedBase &v2);
MICO_Boolean operator>= (const FixedBase &v1, const FixedBase &v2);
MICO_Boolean operator<= (const FixedBase &v1, const FixedBase &v2);
MICO_Boolean operator== (const FixedBase &v1, const FixedBase &v2);
MICO_Boolean operator!= (const FixedBase &v1, const FixedBase &v2);

template<MICO_UShort D, MICO_Short S>
class FixedTmpl : public FixedBase {
public:
    FixedTmpl ()
        : FixedBase (D, S)
    {
    }
    FixedTmpl (MICO_Long v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (MICO_ULong v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (MICO_LongLong v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (MICO_ULongLong v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (MICO_Double v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (MICO_LongDouble v)
        : FixedBase (D, S)
    {
        FixedBase::operator= (FixedBase (v));
    }
    FixedTmpl (const FixedBase &f)
        : FixedBase (D, S)
    {
        FixedBase::operator= (f);
    }
    FixedTmpl (const FixedTmpl<D,S> &f)
        : FixedBase (D, S)
    {
        FixedBase::operator= (f);
    }
    FixedTmpl<D,S> &operator= (MICO_Long v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (MICO_ULong v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (MICO_LongLong v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (MICO_ULongLong v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (MICO_Double v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (MICO_LongDouble v)
    {
        FixedBase::operator= (FixedBase (v));
        return *this;
    }
    FixedTmpl<D,S> &operator= (const FixedBase &f)
    {
        FixedBase::operator= (f);
        return *this;
    }
    FixedTmpl<D,S> &operator= (const FixedTmpl<D,S> &f)
    {
        FixedBase::operator= (f);
        return *this;
    }
    ~FixedTmpl ()
    {
    }
};

typedef FixedBase Fixed;
# 160 "../include/CORBA.h" 2
# 1 "../include/mico/native.h" 1
# 161 "../include/CORBA.h" 2
# 179 "../include/CORBA.h"
# 1 "../include/mico/basic.h" 1
# 27 "../include/mico/basic.h"
namespace CORBA {


typedef MICO_Short Short;
typedef MICO_Short& Short_out;
typedef MICO_Long Long;
typedef MICO_Long& Long_out;
typedef MICO_LongLong LongLong;
typedef MICO_LongLong& LongLong_out;
typedef MICO_UShort UShort;
typedef MICO_UShort& UShort_out;
typedef MICO_ULong ULong;
typedef MICO_ULong& ULong_out;
typedef MICO_ULongLong ULongLong;
typedef MICO_ULongLong& ULongLong_out;
typedef MICO_Float Float;
typedef MICO_Float& Float_out;
typedef MICO_Double Double;
typedef MICO_Double& Double_out;
typedef MICO_LongDouble LongDouble;
typedef MICO_LongDouble& LongDouble_out;
typedef MICO_Char Char;
typedef MICO_Char& Char_out;
typedef MICO_WChar WChar;
typedef MICO_WChar& WChar_out;
typedef MICO_Boolean Boolean;
typedef MICO_Boolean& Boolean_out;
typedef MICO_Octet Octet;
typedef MICO_Octet& Octet_out;


typedef ULong Flags;



class Environment;
class NamedValue;
class NVList;
class ExceptionList;
class ContextList;
class Request;
class Context;
class Principal;
class TypeCode;
class TypeCodeChecker;
class BOA;
class ORB;
class ImplementationDef;
class ImplRepository;
class Repository;
class InterfaceDef;
class OperationDef;
class ServerRequestBase;
class ServerRequest;
class ImplementationBase;
class DynamicImplementation;
class StaticServerRequest;
class ValueDef;

class String_var;
class String_out;
class WString_var;
class WString_out;
class Object;
class Exception;
class SystemException;
class UserException;
class UnknownUserException;
class Any;

class StaticTypeInfo;
class StaticAny;

class DataEncoder;
class DataDecoder;

class ValueBase;
class AbstractBase;

typedef Environment *Environment_ptr;
typedef ObjOut<Environment> Environment_out;
typedef Environment *EnvironmentRef;
typedef NamedValue *NamedValue_ptr;
typedef NamedValue *NamedValueRef;
typedef NVList *NVList_ptr;
typedef NVList *NVListRef;
typedef ExceptionList *ExceptionList_ptr;
typedef ExceptionList *ExceptionListRef;
typedef ContextList *ContextList_ptr;
typedef ObjOut<ContextList> ContextList_out;
typedef ContextList *ContextListRef;
typedef Request *Request_ptr;
typedef ObjOut<Request> Request_out;
typedef Request *RequestRef;
typedef Context *Context_ptr;
typedef Context *ContextRef;
typedef Principal *Principal_ptr;
typedef Principal *PrincipalRef;
typedef TypeCode *TypeCode_ptr;
typedef TypeCode *TypeCodeRef;
typedef ObjVar<TypeCode> TypeCode_var;
typedef ObjOut<TypeCode> TypeCode_out;
typedef BOA *BOA_ptr;
typedef BOA *BOARef;
typedef ORB *ORB_ptr;
typedef ORB *ORBRef;
typedef InterfaceDef *InterfaceDef_ptr;

typedef OperationDef *OperationDef_ptr;

typedef ValueDef *ValueDef_ptr;
typedef ServerRequest *ServerRequest_ptr;
typedef ServerRequest *ServerRequestRef;
typedef ServerRequestBase *ServerRequestBase_ptr;
typedef ServerRequestBase *ServerRequestBaseRef;
typedef StaticServerRequest *StaticServerRequest_ptr;
typedef Object *Object_ptr;
typedef ObjOut<Object> Object_out;
typedef Object *ObjectRef;

}
# 180 "../include/CORBA.h" 2
# 1 "../include/mico/magic.h" 1
# 27 "../include/mico/magic.h"
namespace CORBA {





class MagicChecker {
    ULong magic;
public:
    void _check () const;
    void _check (const CORBA::Exception &) const;
    CORBA::Boolean _check_nothrow () const;
protected:
    MagicChecker ()
    { magic = 0x31415927; }

    ~MagicChecker ()
    { magic = 0; }

    MagicChecker (const MagicChecker &)
    { magic = 0x31415927; }

    MagicChecker &operator= (const MagicChecker &)
    { return *this; }
};

}
# 181 "../include/CORBA.h" 2
# 1 "../include/mico/address.h" 1
# 27 "../include/mico/address.h"
namespace CORBA {




class Address;
class AddressParser;
class Transport;
class TransportServer;
class Buffer;
class IORProfile;
class MultiComponent;





class AddressParser {
public:
    virtual Address *parse (const char *rest, const char *proto) const = 0;
    virtual CORBA::Boolean has_proto (const char *) const = 0;

    virtual ~AddressParser ();
};

class Address {
    static vector<AddressParser *> *parsers;
protected:
    void copy (Address *);
public:
    static Address *parse (const char *);
    static void register_parser (AddressParser *);
    static void unregister_parser (AddressParser *);

    virtual string stringify () const = 0;
    virtual const char *proto () const = 0;
    virtual Transport *make_transport () const = 0;
    virtual TransportServer *make_transport_server () const = 0;
    virtual IORProfile *make_ior_profile (
        Octet *, ULong, const CORBA::MultiComponent &,
        CORBA::UShort version = 0x0100) const = 0;
    virtual Boolean is_local () const = 0;

    virtual Address *clone () const = 0;

    virtual Long compare (const Address &) const = 0;
    virtual Boolean operator== (const Address &) const = 0;
    virtual Boolean operator< (const Address &) const = 0;

    virtual ~Address ();
};

}
# 182 "../include/CORBA.h" 2
# 1 "../include/mico/ioptypes.h" 1
# 12 "../include/mico/ioptypes.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/ioptypes.h" 2



namespace CORBA {




namespace IOP {


typedef CORBA::ULong ServiceID;
typedef ServiceID& ServiceID_out;
struct ServiceContext;
typedef TVarVar<ServiceContext> ServiceContext_var;
typedef TVarOut<ServiceContext> ServiceContext_out;

struct ServiceContext {

  typedef ServiceContext_var _var_type;
# 41 "../include/mico/ioptypes.h"
  ServiceID context_id;
  typedef SequenceTmpl<CORBA::Octet,3> _context_data_seq;
  _context_data_seq context_data;
};

typedef SequenceTmpl<ServiceContext,0> ServiceContextList;



typedef TSeqVar<SequenceTmpl<ServiceContext,0> > ServiceContextList_var;
typedef TSeqOut<SequenceTmpl<ServiceContext,0> > ServiceContextList_out;

extern const CORBA::ULong TransactionService;
extern const CORBA::ULong CodeSets;
extern const CORBA::ULong BI_DIR_IIOP;
typedef CORBA::ULong ComponentId;
typedef ComponentId& ComponentId_out;
struct TaggedComponent;
typedef TVarVar<TaggedComponent> TaggedComponent_var;
typedef TVarOut<TaggedComponent> TaggedComponent_out;

struct TaggedComponent {

  typedef TaggedComponent_var _var_type;
# 73 "../include/mico/ioptypes.h"
  ComponentId tag;
  typedef SequenceTmpl<CORBA::Octet,3> _component_data_seq;
  _component_data_seq component_data;
};

typedef SequenceTmpl<TaggedComponent,0> MultipleComponentProfile;



typedef TSeqVar<SequenceTmpl<TaggedComponent,0> > MultipleComponentProfile_var;
typedef TSeqOut<SequenceTmpl<TaggedComponent,0> > MultipleComponentProfile_out;

}


namespace GIOP {


enum MsgType_1_1 {
  Request = 0,
  Reply,
  CancelRequest,
  LocateRequest,
  LocateReply,
  CloseConnection,
  MessageError,
  Fragment
};

typedef MsgType_1_1& MsgType_1_1_out;

typedef MsgType_1_1 MsgType;
typedef MsgType& MsgType_out;
enum ReplyStatusType_1_2 {
  NO_EXCEPTION = 0,
  USER_EXCEPTION,
  SYSTEM_EXCEPTION,
  LOCATION_FORWARD,
  LOCATION_FORWARD_PERM,
  NEEDS_ADDRESSING_MODE
};

typedef ReplyStatusType_1_2& ReplyStatusType_1_2_out;

typedef ReplyStatusType_1_2 ReplyStatusType;
typedef ReplyStatusType& ReplyStatusType_out;
enum LocateStatusType_1_2 {
  UNKNOWN_OBJECT = 0,
  OBJECT_HERE,
  OBJECT_FORWARD,
  OBJECT_FORWARD_PERM,
  LOC_SYSTEM_EXCEPTION,
  LOC_NEEDS_ADDRESSING_MODE
};

typedef LocateStatusType_1_2& LocateStatusType_1_2_out;

typedef LocateStatusType_1_2 LocateStatusType;
typedef LocateStatusType& LocateStatusType_out;
typedef CORBA::Short AddressingDisposition;
typedef AddressingDisposition& AddressingDisposition_out;
extern const CORBA::Short KeyAddr;
extern const CORBA::Short ProfileAddr;
extern const CORBA::Short ReferenceAddr;
}


namespace IIOP {


struct Version;
typedef TFixVar<Version> Version_var;
typedef Version& Version_out;

struct Version {

  typedef Version_var _var_type;
# 158 "../include/mico/ioptypes.h"
  CORBA::Char major;
  CORBA::Char minor;
};





}


}
# 182 "../include/mico/ioptypes.h"
# 1 "../include/mico/template_impl.h" 1
# 38 "../include/mico/template_impl.h"
template<class T>
T *
ObjVar<T>::duplicate (T *t)
{
    return T::_duplicate (t);
}

template<class T>
void
ObjVar<T>::release (T *t)
{
    CORBA::release (t);
}



template <class T>
ObjOut<T>::ObjOut (T*& p)
  : _ptr (p)
{
    _ptr = T::_nil();
}

template <class T>
ObjOut<T>::ObjOut (ObjVar<T>& p)
  : _ptr (p._ptr)
{
    CORBA::release (_ptr);
    _ptr = T::_nil();
}

template <class T>
ObjOut<T>&
ObjOut<T>::operator= (const ObjVar<T>& p)
{
    _ptr = T::_duplicate (p._ptr);
    return *this;
}




template<class T>
T *
ValueVar<T>::duplicate (T *t)
{
    if (t)
        t->_add_ref();
    return t;
}

template<class T>
void
ValueVar<T>::release (T *t)
{
    if (t)
        t->_remove_ref();
}



template<class T_elem, class T, MICO_ULong n>
SequenceIndTmpl<T_elem,T,n>::SequenceIndTmpl (MICO_ULong maxval,
                                              MICO_ULong lengthval,
                                              T* value,
                                              MICO_Boolean rel)
{
  ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/template_impl.h", 105, __PRETTY_FUNCTION__), 0)));
  vec.reserve (maxval);
  for (MICO_ULong i = 0; i < lengthval; ++i) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = (T_elem*) (value + i);
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  if (rel)
    freebuf (value);
}

template<class T_elem, class T, MICO_ULong n>
void
SequenceIndTmpl<T_elem,T,n>::replace (MICO_ULong maxval,
                                      MICO_ULong lengthval,
                                      T* value,
                                      MICO_Boolean rel)
{
  ((void) ((lengthval <= maxval) ? 0 : (__assert_fail ("lengthval <= maxval", "../include/mico/template_impl.h", 131, __PRETTY_FUNCTION__), 0)));
  for( mico_vec_size_type i0 = 0; i0 < vec.size(); i0++ )
    delete[] vec[ i0 ];
  vec.erase (vec.begin(), vec.end());
  vec.reserve (max);
  for (MICO_ULong i1 = 0; i1 < lengthval; ++i1) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = (T_elem*) (value + i1);
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  if (rel)
    freebuf (value);
}

template<class T_elem, class T, MICO_ULong n>
SequenceIndTmpl<T_elem,T,n>::
SequenceIndTmpl (const SequenceIndTmpl<T_elem,T,n> &s)
{
  for( CORBA::ULong i = 0; i < s.length(); i++ ) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = s.vec[ i ];
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
}

template<class T_elem, class T, MICO_ULong n>
SequenceIndTmpl<T_elem,T,n>::~SequenceIndTmpl ()
{
  for( mico_vec_size_type i = 0; i < vec.size(); i++ )
    delete[] vec[ i ];
}

template<class T_elem, class T, MICO_ULong n>
SequenceIndTmpl<T_elem,T,n>&
SequenceIndTmpl<T_elem,T,n>::operator= (const SequenceIndTmpl<T_elem,T,n> &s)
{
  for( mico_vec_size_type i0 = 0; i0 < vec.size(); i0++ )
    delete[] vec[ i0 ];
  vec.erase( vec.begin(), vec.end() );
  for( MICO_ULong i1 = 0; i1 < s.length(); i1++ ) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = s.vec[ i1 ];
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  return *this;
}

template<class T_elem, class T, MICO_ULong n>
void
SequenceIndTmpl<T_elem,T,n>::length (MICO_ULong l)
{
  if (l < vec.size ()) {
    for( mico_vec_size_type i = l; i < vec.size(); i++ )
      delete[] vec[ i ];
    vec.erase (vec.begin() + l, vec.end());
  } else if (l > vec.size()) {
    int limit = l - vec.size();
    for( int i = 0; i < limit; i++ )
      vec.push_back( new T_elem[ n ] );
  }
}

template<class T_elem, class T, MICO_ULong n>
T*
SequenceIndTmpl<T_elem,T,n>::allocbuf (MICO_ULong len)
{
  return (T*) new T_elem[ n * len ];
}

template<class T_elem, class T, MICO_ULong n>
void
SequenceIndTmpl<T_elem,T,n>::freebuf( T* b )
{
  delete[] (T_elem*) b;
}




template<class T_elem, class T, MICO_ULong n, int max>
BoundedSequenceIndTmpl<T_elem,T,n,max>::
BoundedSequenceIndTmpl (MICO_ULong lengthval, T *value,
                        MICO_Boolean rel)
{
  ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/template_impl.h", 239, __PRETTY_FUNCTION__), 0)));
  vec.reserve (max);
  for (MICO_ULong i = 0; i < lengthval; ++i) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = (T_elem*) (value + i);
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  if (rel)
    freebuf (value);
}

template<class T_elem, class T, MICO_ULong n, int max>
void
BoundedSequenceIndTmpl<T_elem,T,n,max>::replace (MICO_ULong lengthval, T *value,
                                                 MICO_Boolean rel)
{
  ((void) ((lengthval <= max) ? 0 : (__assert_fail ("lengthval <= max", "../include/mico/template_impl.h", 263, __PRETTY_FUNCTION__), 0)));
  for( mico_vec_size_type i0 = 0; i0 < vec.size(); i0++ )
    delete[] vec[ i0 ];
  vec.erase (vec.begin(), vec.end());
  vec.reserve (max);
  for (MICO_ULong i1 = 0; i1 < lengthval; ++i1) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = (T_elem*) (value + i1);
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  if (rel)
    freebuf (value);
}

template<class T_elem, class T, MICO_ULong n, int max>
BoundedSequenceIndTmpl<T_elem,T,n,max>::
BoundedSequenceIndTmpl (const BoundedSequenceIndTmpl<T_elem,T,n,max> &s)
{
  vec.reserve( max );
  for( CORBA::ULong i = 0; i < s.length(); i++ ) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = s.vec[ i ];
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
}

template<class T_elem, class T, MICO_ULong n, int max>
BoundedSequenceIndTmpl<T_elem,T,n,max>::~BoundedSequenceIndTmpl ()
{
  for( mico_vec_size_type i = 0; i < vec.size(); i++ )
    delete[] vec[ i ];
}

template<class T_elem, class T, MICO_ULong n, int max>
BoundedSequenceIndTmpl<T_elem,T,n, max> &
BoundedSequenceIndTmpl<T_elem,T,n,max>::
operator= (const BoundedSequenceIndTmpl<T_elem,T,n, max> &s)
{
  for( mico_vec_size_type i0 = 0; i0 < vec.size(); i0++ )
    delete[] vec[ i0 ];
  vec.erase( vec.begin(), vec.end() );
  for( MICO_ULong i1 = 0; i1 < s.length(); i1++ ) {
    T_elem* new_elem = new T_elem[ n ];
    T_elem* dest = new_elem;
    T_elem* src = s.vec[ i1 ];
    MICO_ULong j = 0;
    while( j < n ) {
      *dest = *src;
      ++dest;
      ++src;
      j++;
    }
    vec.push_back ( new_elem );
  }
  return *this;
}

template<class T_elem, class T, MICO_ULong n, int max>
void
BoundedSequenceIndTmpl<T_elem,T,n,max>::length (MICO_ULong l)
{
  ((void) ((l <= max) ? 0 : (__assert_fail ("l <= max", "../include/mico/template_impl.h", 340, __PRETTY_FUNCTION__), 0)));
  if (l < vec.size ()) {
    for( mico_vec_size_type i = l; i < vec.size(); i++ )
      delete[] vec[ i ];
    vec.erase (vec.begin() + l, vec.end());
  } else if (l > vec.size()) {
    int limit = l - vec.size();
    for( int i = 0; i < limit; i++ )
      vec.push_back( new T_elem[ n ] );
  }
}

template<class T_elem, class T, MICO_ULong n, int max>
T*
BoundedSequenceIndTmpl<T_elem,T,n,max>::allocbuf (MICO_ULong len)
{
  return (T*) new T_elem[ n * len ];
}

template<class T_elem, class T, MICO_ULong n, int max>
void
BoundedSequenceIndTmpl<T_elem,T,n,max>::freebuf (T *b)
{
  delete[] (T_elem*) b;
}
# 183 "../include/mico/ioptypes.h" 2
# 183 "../include/CORBA.h" 2
# 1 "../include/mico/ior.h" 1
# 27 "../include/mico/ior.h"
namespace CORBA {




class IOR;
class IORProfile;
class IORProfileDecoder;
class Component;
class ComponentDecoder;
class DataDecoder;
class DataEncoder;
class Address;





class Component {
    static vector<ComponentDecoder *> *decoders;
protected:
    void copy (Component *);
public:
    typedef CORBA::ULong ComponentId;
    enum {
        TAG_CODE_SETS = 1,
        TAG_SSL_SEC_TRANS = 20
    };

    static Component *decode (DataDecoder &);
    static Component *decode_body (DataDecoder &, ComponentId, ULong len);
    static void register_decoder (ComponentDecoder *);
    static void unregister_decoder (ComponentDecoder *);

    virtual void encode (DataEncoder &) const = 0;
    virtual ComponentId id () const = 0;
    virtual void print (ostream &) const = 0;

    virtual Component *clone () const = 0;
    virtual Long compare (const Component &) const = 0;
    virtual Boolean operator== (const Component &) const = 0;
    virtual Boolean operator< (const Component &) const = 0;

    virtual ~Component ();
};

class ComponentDecoder {
public:
    typedef Component::ComponentId ComponentId;

    virtual Component *decode (DataDecoder &, ComponentId, ULong) const = 0;
    virtual CORBA::Boolean has_id (ComponentId) const = 0;

    virtual ~ComponentDecoder ();
};

class MultiComponent {
    vector<Component *> _comps;
    void free ();
    void copy (const MultiComponent &);
public:
    typedef Component::ComponentId ComponentId;

    MultiComponent ();
    MultiComponent (const MultiComponent &);
    MultiComponent &operator= (const MultiComponent &);
    ~MultiComponent ();

    CORBA::Long compare (const MultiComponent &) const;
    CORBA::Boolean operator< (const MultiComponent &) const;
    CORBA::Boolean operator== (const MultiComponent &) const;

    void add_component (Component *);
    void del_component (Component *);
    Component *component (ComponentId);

    void encode (DataEncoder &) const;
    CORBA::Boolean decode (DataDecoder &);
    void print (ostream &) const;
    CORBA::ULong size () const;
};



class IORProfile {
    static vector<IORProfileDecoder *> *decoders;
protected:
    void copy (IORProfile *);
public:
    typedef CORBA::ULong ProfileId;
    enum {
        TAG_INTERNET_IOP = 0,
        TAG_MULTIPLE_COMPONENTS = 1,
        TAG_LOCAL = 20000,
        TAG_ANY = 20001,
        TAG_UNIX_IOP = 20002,
        TAG_SSL_INTERNET_IOP = 20002,
        TAG_SSL_UNIX_IOP = 20003,
        TAG_UDP_IOP = 20004,
        TAG_SSL_UDP_IOP = 20005
    };

    static IORProfile *decode (DataDecoder &);
    static IORProfile *decode_body (DataDecoder &, ProfileId, ULong len);
    static void register_decoder (IORProfileDecoder *);
    static void unregister_decoder (IORProfileDecoder *);

    virtual void encode (DataEncoder &) const = 0;
    virtual const Address *addr () const = 0;
    virtual ProfileId id () const = 0;
    virtual ProfileId encode_id () const = 0;
    virtual void objectkey (Octet *, Long length) = 0;
    virtual const Octet *objectkey (Long &length) const = 0;
    virtual Boolean reachable () = 0;
    virtual void print (ostream &) const = 0;
    virtual CORBA::MultiComponent *components ();

    virtual IORProfile *clone () const = 0;
    virtual Long compare (const IORProfile &) const = 0;
    virtual Boolean operator== (const IORProfile &) const = 0;
    virtual Boolean operator< (const IORProfile &) const = 0;

    virtual ~IORProfile ();
};

class IORProfileDecoder {
public:
    typedef IORProfile::ProfileId ProfileId;

    virtual IORProfile *decode (DataDecoder &, ProfileId, ULong) const = 0;
    virtual CORBA::Boolean has_id (ProfileId) const = 0;

    virtual ~IORProfileDecoder ();
};

class IOR {
public:
    typedef vector<IORProfile *> IORProfileVec;

private:
    string oid;
    IORProfileVec tags;

    void free ();
    void copy (const IOR &);

    IORProfile * _active_profile;
    CORBA::ULong _active_profile_index;
    CORBA::GIOP::AddressingDisposition _addressing_disposition;

public:
    IOR ();
    IOR (const char *objid, const IORProfileVec &tags);
    IOR (DataDecoder &);
    IOR (const char *);
    IOR (const IOR &);
    ~IOR ();
    IOR &operator= (const IOR &);
    Boolean from_string (const char *);
    Long compare (const IOR &) const;
    Long compare_reachable (const IOR &) const;
    Boolean operator== (const IOR &) const;
    Boolean operator< (const IOR &) const;

    const Address *addr (IORProfile::ProfileId = IORProfile::TAG_ANY,
                         Boolean find_unreachable = 0,
                         const Address *prev = 0) const;
    IORProfile *profile (IORProfile::ProfileId = IORProfile::TAG_ANY,
                         Boolean find_unreachable = 0,
                         IORProfile *prev = 0);
    void add_profile (IORProfile *);
    void del_profile (IORProfile *);
    IORProfile *get_profile (ULong);

    IORProfile * active_profile (CORBA::ULong * index = 0);
    void active_profile (IORProfile *);

    CORBA::GIOP::AddressingDisposition addressing_disposition ();
    void addressing_disposition (CORBA::GIOP::AddressingDisposition);

    const char *objid () const;
    void objid (const char *);
    void objectkey (Octet *, ULong len);
    void encode (DataEncoder &) const;
    Boolean decode (DataDecoder &);
    string stringify () const;
    void print (ostream &) const;
};

}
# 184 "../include/CORBA.h" 2
# 1 "../include/mico/transport.h" 1
# 27 "../include/mico/transport.h"
namespace CORBA {




class Address;
class Dispatcher;
struct DispatcherCallback;
class Transport;
struct TransportCallback;
class TransportServer;
struct TransportServerCallback;
class Buffer;





class Dispatcher {
public:
    enum Event { Timer, Read, Write, Except, All, Remove, Moved };
    virtual void rd_event (DispatcherCallback *, Long fd) = 0;
    virtual void wr_event (DispatcherCallback *, Long fd) = 0;
    virtual void ex_event (DispatcherCallback *, Long fd) = 0;
    virtual void tm_event (DispatcherCallback *, ULong tmout) = 0;
    virtual void remove (DispatcherCallback *, Event) = 0;
    virtual void run (Boolean infinite = 1) = 0;
    virtual void move (Dispatcher *) = 0;
    virtual Boolean idle () const = 0;

    virtual ~Dispatcher ();
};

struct DispatcherCallback {
    typedef Dispatcher::Event Event;
    virtual void callback (Dispatcher *, Event) = 0;
    virtual ~DispatcherCallback ();
};

class Timeout : public DispatcherCallback {
    Boolean _ready;
    Dispatcher *_disp;
    Boolean _have_tmout;
public:
    Timeout (Dispatcher *d, Long tm);
    ~Timeout ();
    void callback (Dispatcher *, Event);
    Boolean done () const
    {
        return _ready;
    }
};


class Transport {
public:
    virtual void rselect (Dispatcher *, TransportCallback *) = 0;
    virtual void wselect (Dispatcher *, TransportCallback *) = 0;

    virtual Boolean bind (const Address *) = 0;
    virtual Boolean connect (const Address *) = 0;
    virtual void close () = 0;
    virtual void block (Boolean doblock = 1) = 0;
    virtual CORBA::Boolean isblocking () = 0;
    virtual void buffering (Boolean dobuffering = 1);
    virtual CORBA::Boolean isbuffering ();
    virtual CORBA::Boolean isreadable () = 0;

    Long read (Buffer &, Long len);
    virtual Long read (void *, Long len) = 0;
    Long write (Buffer &, Long len, Boolean eat = 1);
    virtual Long write (const void *, Long len) = 0;

    virtual const Address *addr () = 0;
    virtual const Address *peer () = 0;

    virtual Boolean eof () const = 0;
    virtual Boolean bad () const = 0;
    virtual string errormsg () const = 0;

    virtual CORBA::Principal_ptr get_principal ();

    virtual ~Transport ();
};

struct TransportCallback {
    enum Event { Read, Write, Remove };
    virtual void callback (Transport *, Event) = 0;
    virtual ~TransportCallback ();
};


class TransportServer {
public:
    virtual void aselect (Dispatcher *, TransportServerCallback *) = 0;

    virtual Boolean bind (const Address *) = 0;
    virtual void close () = 0;
    virtual void block (Boolean doblock = 1) = 0;
    virtual CORBA::Boolean isblocking () = 0;

    virtual Transport *accept () = 0;
    virtual const Address *addr () = 0;

    virtual Boolean bad () const = 0;
    virtual string errormsg () const = 0;

    virtual ~TransportServer ();
};

struct TransportServerCallback {
    enum Event { Accept, Remove };
    virtual void callback (TransportServer *, Event) = 0;
    virtual ~TransportServerCallback ();
};

}
# 185 "../include/CORBA.h" 2
# 1 "../include/mico/buffer.h" 1
# 27 "../include/mico/buffer.h"
namespace CORBA {

class Buffer {
    enum {
        MINSIZE = 128,
        RESIZE_THRESH = 10000,
        RESIZE_INCREMENT = 10000
    };
    Boolean _readonly;
    ULong _rptr, _wptr;
    ULong _ralignbase, _walignbase;
    ULong _len;
    Octet *_buf;

    Octet *alloc (ULong sz);
    Octet *realloc (Octet *, ULong osz, ULong nsz);
    void free (Octet *);
public:
    Buffer (void *);
    Buffer (ULong sz = 0);
    Buffer (const Buffer &);
    ~Buffer ();
    Buffer &operator= (const Buffer &);
    Boolean operator== (const Buffer &);

    void reset (ULong size = MINSIZE);
    void resize (ULong needed);

    Boolean rseek_rel (Long offs)
    {
        if (_rptr + offs > _wptr)
            return 0;
        _rptr += offs;
        return 1;
    }
    Boolean rseek_beg (ULong offs)
    {
        if (offs > _wptr)
            return 0;
        _rptr = offs;
        return 1;
    }
    Boolean rseek_end (ULong offs)
    {
        if (offs > _len || _len - offs > _wptr)
            return 0;
        _rptr = _len - offs;
        return 1;
    }
    ULong ralign_base () const
    {
        return _ralignbase;
    }
    void ralign_base (ULong b)
    {
        _ralignbase = b;
    }
    ULong rpos () const
    {
        return _rptr;
    }

    Boolean ralign (ULong modulo);

    Boolean peek (void *, ULong blen);
    Boolean peek (Octet &);

    Boolean get (void *, ULong blen);
    Boolean get (Octet &);
    Boolean get1 (void *);
    Boolean get2 (void *);
    Boolean get4 (void *);
    Boolean get8 (void *);
    Boolean get16 (void *);

    void wseek_rel (Long offs)
    {
        ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "../include/mico/buffer.h", 104, __PRETTY_FUNCTION__), 0)));
        ((void) ((_wptr + offs >= _rptr && _wptr + offs <= _len) ? 0 : (__assert_fail ("_wptr + offs >= _rptr && _wptr + offs <= _len", "../include/mico/buffer.h", 105, __PRETTY_FUNCTION__), 0)));

        _wptr += offs;
    }
    void wseek_beg (ULong offs)
    {
        ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "../include/mico/buffer.h", 111, __PRETTY_FUNCTION__), 0)));
        ((void) ((offs >= _rptr && offs <= _len) ? 0 : (__assert_fail ("offs >= _rptr && offs <= _len", "../include/mico/buffer.h", 112, __PRETTY_FUNCTION__), 0)));

        _wptr = offs;
    }
    void wseek_end (ULong offs)
    {
        ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "../include/mico/buffer.h", 118, __PRETTY_FUNCTION__), 0)));
        ((void) ((_len - offs >= _rptr) ? 0 : (__assert_fail ("_len - offs >= _rptr", "../include/mico/buffer.h", 119, __PRETTY_FUNCTION__), 0)));
        _wptr = _len - offs;
    }
    ULong walign_base () const
    {
        return _walignbase;
    }
    void walign_base (ULong b)
    {
        _walignbase = b;
    }
    ULong wpos () const
    {
        ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "../include/mico/buffer.h", 132, __PRETTY_FUNCTION__), 0)));
        return _wptr;
    }

    void walign (ULong modulo);

    void replace (const void *, ULong blen);
    void replace (Octet);

    void put (const void *, ULong blen);
    void put (Octet);
    void put1 (const void *);
    void put2 (const void *);
    void put4 (const void *);
    void put8 (const void *);
    void put16 (const void *);

    ULong length () const
    {
        ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "../include/mico/buffer.h", 151, __PRETTY_FUNCTION__), 0)));
        return _wptr - _rptr;
    }
    Octet *data ()
    {
        return &_buf[_rptr];
    }
    const Octet *data () const
    {
        return &_buf[_rptr];
    }
    Octet *wdata ()
    {
        return &_buf[_wptr];
    }
    const Octet *wdata () const
    {
        return &_buf[_wptr];
    }
    Octet *buffer ()
    {
        return _buf;
    }
    const Octet *buffer () const
    {
        return _buf;
    }

    void dump (const char *, ostream &) const;
};

typedef TVarVar<Buffer> Buffer_var;

}
# 186 "../include/CORBA.h" 2
# 1 "../include/mico/codeset.h" 1
# 27 "../include/mico/codeset.h"
namespace CORBA {

class Codeset {
public:
    typedef CORBA::ULong CodesetId;
    typedef CORBA::UShort CharsetId;

    enum { MAX_CHARSETS = 5 };

    struct Info {
        CodesetId id;
        CORBA::UShort codepoint_size;
        CORBA::UShort max_codepoints;
        CharsetId charsets[MAX_CHARSETS];
        const char *desc;
        const char *name;
    };

    enum SpecialCS {
        _SpecialMin,
        NativeCS = 0,
        NativeWCS,
        FallbackCS,
        FallbackWCS,
        DefaultCS,
        DefaultWCS,
        _SpecialMax
    };
private:
    static CORBA::Boolean _disabled;
    static Codeset *_special[_SpecialMax];
    Info *_info;

    Codeset ();
    Codeset (Info *);
public:
    static void disable (CORBA::Boolean d)
    { _disabled = d; }

    static CORBA::Boolean disabled ()
    { return _disabled; }

    Codeset (const Codeset &);
    ~Codeset ();

    static void _init ();

    static Info *_find_info (CodesetId);
    static Info *_find_info (const char *);

    static Codeset *create (CodesetId);
    static Codeset *create (const char *);

    static Codeset *special_cs (SpecialCS);
    static void set_special_cs (SpecialCS, Codeset *);

    CORBA::Boolean is_compatible (const Codeset *) const;
    CORBA::Boolean is_compatible (CodesetId) const;

    CodesetId id () const
    { return _info->id; }

    const char *name () const
    { return _info->name; }

    const char *desc () const
    { return _info->desc; }

    CORBA::UShort codepoint_size () const
    { return _info->codepoint_size; }

    CORBA::UShort max_codepoints () const
    { return _info->max_codepoints; }

    CORBA::ULong guess_size (CORBA::ULong nchars) const
    { return (nchars+1) * _info->max_codepoints; }
};
# 112 "../include/mico/codeset.h"
class CodeSetCoder {
public:
  virtual ~CodeSetCoder ();

  virtual CodeSetCoder * clone () = 0;
  virtual CORBA::Boolean isok () = 0;





  virtual CORBA::Boolean get_char (CORBA::DataDecoder &,
                                   CORBA::Char &) = 0;
  virtual CORBA::Boolean get_chars (CORBA::DataDecoder &,
                                    CORBA::Char *,
                                    CORBA::ULong) = 0;
  virtual CORBA::Boolean get_string (CORBA::DataDecoder &,
                                     CORBA::String_out,
                                     CORBA::ULong) = 0;
  virtual CORBA::Boolean get_wchar (CORBA::DataDecoder &,
                                    CORBA::WChar &) = 0;
  virtual CORBA::Boolean get_wchars (CORBA::DataDecoder &,
                                     CORBA::WChar *,
                                     CORBA::ULong) = 0;
  virtual CORBA::Boolean get_wstring (CORBA::DataDecoder &,
                                      CORBA::WString_out,
                                      CORBA::ULong) = 0;





  virtual CORBA::Boolean put_char (CORBA::DataEncoder &,
                                   CORBA::Char) = 0;
  virtual CORBA::Boolean put_chars (CORBA::DataEncoder &,
                                    const CORBA::Char *,
                                    CORBA::ULong) = 0;
  virtual CORBA::Boolean put_string (CORBA::DataEncoder &,
                                     const char *,
                                     CORBA::ULong) = 0;
  virtual CORBA::Boolean put_wchar (CORBA::DataEncoder &,
                                    CORBA::WChar) = 0;
  virtual CORBA::Boolean put_wchars (CORBA::DataEncoder &,
                                     const CORBA::WChar *,
                                     CORBA::ULong) = 0;
  virtual CORBA::Boolean put_wstring (CORBA::DataEncoder &,
                                      const CORBA::WChar *,
                                      CORBA::ULong) = 0;
};

}
# 187 "../include/CORBA.h" 2
# 1 "../include/mico/string.h" 1
# 27 "../include/mico/string.h"
namespace CORBA {

class String_out;

class String_var {

    friend class String_out;

private:
    char* _str;

public:
    String_var ();
    String_var (char *);
    String_var (const char *);
    String_var (const String_var &);
    ~String_var ();

    String_var &operator= (char *);
    String_var &operator= (const char *);
    String_var &operator= (const String_var &);

    Boolean operator== (const String_var &s) const;
# 65 "../include/mico/string.h"
    operator char* () const
    {
        return _str;
    }


    char &operator[] (ULong idx)
    { return _str[idx]; }

    char operator[] (ULong idx) const
    { return _str[idx]; }

    const char *in () const;
    char *&out ();
    char *&inout ();
    char *&_for_demarshal ()
    { return out(); }

    char * _retn ();
};


class String_out {
private:
    char*& _str;

public:
    String_out (char *&);
    String_out (String_var &);
    String_out (const String_out &);

    String_out &operator= (const String_out &);
    String_out &operator= (char *);
    String_out &operator= (const char *);

    operator char*& ()
    {
        return _str;
    }

    char*& ptr ()
    {
        return _str;
    }

private:

    void operator= (const String_var&);
};


extern char *string_alloc (ULong len);
extern char *string_dup (const char *);
extern char *string_ndup (const char *, ULong len);
extern void string_free (char *);


class WString_out;

class WString_var {

    friend class WString_out;

    wchar_t* _str;

public:
    WString_var ();
    WString_var (wchar_t *);
    WString_var (const wchar_t *);
    WString_var (const WString_var &);
    ~WString_var ();

    WString_var &operator= (wchar_t *);
    WString_var &operator= (const wchar_t *);
    WString_var &operator= (const WString_var &);

    Boolean operator== (const WString_var &s) const;
# 156 "../include/mico/string.h"
    operator wchar_t* () const
    {
        return _str;
    }


    wchar_t &operator[] (ULong idx)
    { return _str[idx]; }

    wchar_t operator[] (ULong idx) const
    { return _str[idx]; }

    const wchar_t *in () const;
    wchar_t *&out ();
    wchar_t *&inout ();
    wchar_t *&_for_demarshal ()
    { return out(); }

    wchar_t * _retn ();
};


class WString_out {
private:
    wchar_t*& _str;

public:
    WString_out (wchar_t *&);
    WString_out (WString_var &);
    WString_out (const WString_out &);

    WString_out &operator= (const WString_out &);
    WString_out &operator= (wchar_t *);
    WString_out &operator= (const wchar_t *);

    operator wchar_t*& ()
    {
        return _str;
    }

    wchar_t*& ptr ()
    {
        return _str;
    }

private:

    void operator= (const WString_var&);
};


extern wchar_t *wstring_alloc (ULong len);
extern wchar_t *wstring_dup (const wchar_t *);
extern wchar_t *wstring_ndup (const wchar_t *, ULong len);
extern void wstring_free (wchar_t *);

}
# 188 "../include/CORBA.h" 2
# 1 "../include/mico/codec.h" 1
# 27 "../include/mico/codec.h"
namespace CORBA {




class Buffer;





enum ByteOrder {
    BigEndian,
    LittleEndian,
    DefaultEndian
};


class DataEncoder {
public:
    struct EncapsState {
        ULong pos;
        ByteOrder bo;
        ULong align;
    };
    struct DelayedSeqState {
        ULong pos;
    };

    typedef map<ValueBase *, Long, less<ValueBase *> > MapValueId;

    class ValueState {
        friend class DataEncoder;
        Long chunk_level;
        Long nesting_level;
        Long tag_pos;
    public:
        MapValueId visited;

        void reset ()
        {
            chunk_level = 0x7fffffff;
            nesting_level = 0;
            tag_pos = -1;
            visited.erase (visited.begin(), visited.end());
        }
        ValueState ()
        {
            chunk_level = 0x7fffffff;
            nesting_level = 0;
            tag_pos = -1;
        }
        ValueState (const ValueState &vs)
            : chunk_level (vs.chunk_level), nesting_level (vs.nesting_level),
              tag_pos (vs.tag_pos), visited (vs.visited)
        {
        }
        ~ValueState ()
        {
        }
        ValueState &operator= (const ValueState &vs)
        {
            chunk_level = vs.chunk_level;
            nesting_level = vs.nesting_level;
            tag_pos = vs.tag_pos;
            visited = vs.visited;
            return *this;
        }
    };

protected:
    Buffer *buf;
    Boolean dofree_buf;
    CodeSetCoder *conv;
    Boolean dofree_conv;
    ValueState *vstate;
    Boolean dofree_vstate;

public:
    DataEncoder ();
    DataEncoder (Buffer *b, Boolean dofree_b = 1,
                 CodeSetCoder *c = 0, Boolean dofree_c = 1,
                 ValueState *vs = 0, Boolean dofree_vs = 1);
    virtual ~DataEncoder ();

    virtual DataEncoder *clone () const = 0;
    virtual DataEncoder *clone (Buffer *b, Boolean dofree_b = 1,
                                CodeSetCoder *c = 0,
                                Boolean dofree_c = 1,
                                ValueState *vs = 0,
                                Boolean dofree_vs = 1) const = 0;
    virtual DataDecoder *decoder () const = 0;
    virtual DataDecoder *decoder (Buffer *b, Boolean dofree_b = 1,
                                  CodeSetCoder *c = 0,
                                  Boolean dofree_c = 1) const = 0;
    virtual const char *type () const = 0;

    virtual void put_short (Short) = 0;
    virtual void put_ushort (UShort) = 0;
    virtual void put_long (Long) = 0;
    virtual void put_longlong (LongLong) = 0;
    virtual void put_ulong (ULong) = 0;
    virtual void put_ulonglong (ULongLong) = 0;
    virtual void put_float (Float) = 0;
    virtual void put_double (Double) = 0;
    virtual void put_longdouble (LongDouble) = 0;
    virtual void put_char (Char) = 0;
    virtual void put_char_raw (Char) = 0;
    virtual void put_wchar (WChar) = 0;
    virtual void put_octet (Octet) = 0;
    virtual void put_boolean (Boolean) = 0;
    virtual void put_string (const char *) = 0;
    virtual void put_string_raw (const char *) = 0;
    virtual void put_wstring (const wchar_t *) = 0;
    virtual void put_fixed (const FixedBase::FixedValue &value,
                            UShort digits, Short scale) = 0;

    virtual void put_shorts (const Short *, ULong) = 0;
    virtual void put_ushorts (const UShort *, ULong) = 0;
    virtual void put_longs (const Long *, ULong) = 0;
    virtual void put_longlongs (const LongLong *, ULong) = 0;
    virtual void put_ulongs (const ULong *, ULong) = 0;
    virtual void put_ulonglongs (const ULongLong *, ULong) = 0;
    virtual void put_floats (const Float *, ULong) = 0;
    virtual void put_doubles (const Double *, ULong) = 0;
    virtual void put_longdoubles (const LongDouble *, ULong) = 0;
    virtual void put_chars (const Char *, ULong) = 0;
    virtual void put_chars_raw (const Char *, ULong) = 0;
    virtual void put_wchars (const WChar *, ULong) = 0;
    virtual void put_booleans (const Boolean *, ULong) = 0;

    virtual void put_context (const Context &, ContextList_ptr = 0);
    virtual void put_principal (const Principal &);
    virtual void put_any (const Any &);
    virtual void put_typecode (const TypeCode &);
    virtual void put_ior (const IOR &);

    void put_string (const string &s);
    void put_string_raw (const string &s);
    virtual void put_buffer (const Buffer &);
    virtual void put_octets (const void *, ULong len);

    virtual void enumeration (ULong);

    virtual void struct_begin ();
    virtual void struct_end ();

    virtual void except_begin (const string &repoid);
    virtual void except_end ();

    virtual void seq_begin (ULong);
    virtual void seq_end ();

    virtual void encaps_begin (EncapsState &state);
    virtual void encaps_end (EncapsState &state);

    virtual void delayed_seq_begin (DelayedSeqState &state);
    virtual void delayed_seq_end (DelayedSeqState &state, ULong size);

    virtual void union_begin ();
    virtual void union_end ();

    virtual void arr_begin ();
    virtual void arr_end ();

    virtual void value_begin (const string &url,
                              const vector<string> &repoids,
                              Boolean chunked,
                              Long &value_id,
                              ValueState &state);
    void value_begin (const string &url,
                      const vector<string> &repoids,
                      Boolean chunked,
                      Long &value_id);
    virtual void value_end (Long value_id, ValueState &state);
    void value_end (Long value_id);
    virtual void value_ref (Long value_id);

    virtual ULong max_alignment () const = 0;

    Buffer *buffer ()
    { return buf; }

    void buffer (Buffer *, Boolean dofree = 1);

    virtual ByteOrder byteorder () const;
    virtual void byteorder (ByteOrder);

    CodeSetCoder *converter ()
    { return conv; }

    void converter (CodeSetCoder *, Boolean dofree = 1);

    ValueState *valuestate ()
    { return vstate; }

    void valuestate (ValueState *vs, Boolean dofree = 1);
};


class DataDecoder {
public:
    typedef DataEncoder::EncapsState EncapsState;

    struct ValueState1 {
        Long chunk_level;
        Long nesting_level;
        Long data_nesting_level;
        Long saved_pos;

        void reset ()
        {
            chunk_level = 0x7fffffff;
            nesting_level = 0;
            data_nesting_level = 0;
            saved_pos = -1;
        }
        ValueState1 ()
        {
            reset();
        }
    };
    typedef map<Long, ValueState1, less<Long> > MapIdState;
    typedef map<Long, ValueBase *, less<Long> > MapIdValue;

    class ValueState {
        friend class DataDecoder;
        ValueState1 s;
        MapIdState skipped;
    public:
        MapIdValue visited;

        void reset ()
        {
            s.reset();
            skipped.erase (skipped.begin(), skipped.end());
            visited.erase (visited.begin(), visited.end());
        }

        ValueState ()
        {
        }
        ValueState (const ValueState &vs)
            : s (vs.s), skipped (vs.skipped), visited (vs.visited)
        {
        }
        ~ValueState ()
        {
        }
        ValueState &operator= (const ValueState &vs)
        {
            s = vs.s;
            skipped = vs.skipped;
            visited = vs.visited;
            return *this;
        }
    };

protected:
    Buffer *buf;
    Boolean dofree_buf;
    CodeSetCoder *conv;
    Boolean dofree_conv;
    ValueState *vstate;
    Boolean dofree_vstate;

    Boolean get_indirect_string (string &s);
    Boolean get_indirect_string_seq (vector<string> &s);
public:

    DataDecoder (Buffer *b, Boolean dofree_b = 1,
                 CodeSetCoder *c = 0, Boolean dofree_c = 1,
                 ValueState *vs = 0, Boolean dofree_vs = 1);
    virtual ~DataDecoder ();

    virtual DataDecoder *clone () const = 0;
    virtual DataDecoder *clone (Buffer *b, Boolean dofree_b = 1,
                                CodeSetCoder *c = 0,
                                Boolean dofree_c = 1,
                                ValueState *vs = 0,
                                Boolean dofree_vs = 1) const = 0;
    virtual DataEncoder *encoder () const = 0;
    virtual DataEncoder *encoder (Buffer *b, Boolean dofree_b = 1,
                                  CodeSetCoder *c = 0,
                                  Boolean dofree_c = 1) const = 0;
    virtual const char *type () const = 0;

    virtual Boolean get_short (Short &) = 0;
    virtual Boolean get_ushort (UShort &) = 0;
    virtual Boolean get_long (Long &) = 0;
    virtual Boolean get_longlong (LongLong &) = 0;
    virtual Boolean get_ulong (ULong &) = 0;
    virtual Boolean get_ulonglong (ULongLong &) = 0;
    virtual Boolean get_float (Float &) = 0;
    virtual Boolean get_double (Double &) = 0;
    virtual Boolean get_longdouble (LongDouble &) = 0;
    virtual Boolean get_char (Char &) = 0;
    virtual Boolean get_char_raw (Char &) = 0;
    virtual Boolean get_wchar (WChar &) = 0;
    virtual Boolean get_octet (Octet &) = 0;
    virtual Boolean get_boolean (Boolean &) = 0;
    virtual Boolean get_string (String_out) = 0;
    virtual Boolean get_string_raw (String_out) = 0;
    virtual Boolean get_wstring (WString_out) = 0;
    virtual Boolean get_fixed (FixedBase::FixedValue &val,
                               UShort digits, Short scale) = 0;

    virtual Boolean get_shorts (Short *, ULong) = 0;
    virtual Boolean get_ushorts (UShort *, ULong) = 0;
    virtual Boolean get_longs (Long *, ULong) = 0;
    virtual Boolean get_longlongs (LongLong *, ULong) = 0;
    virtual Boolean get_ulongs (ULong *, ULong) = 0;
    virtual Boolean get_ulonglongs (ULongLong *, ULong) = 0;
    virtual Boolean get_floats (Float *, ULong) = 0;
    virtual Boolean get_doubles (Double *, ULong) = 0;
    virtual Boolean get_longdoubles (LongDouble *, ULong) = 0;
    virtual Boolean get_chars (Char *, ULong) = 0;
    virtual Boolean get_chars_raw (Char *, ULong) = 0;
    virtual Boolean get_wchars (WChar *, ULong) = 0;
    virtual Boolean get_booleans (Boolean *, ULong) = 0;

    virtual Boolean get_context (Context &);
    virtual Boolean get_principal (Principal &);
    virtual Boolean get_any (Any &);
    virtual Boolean get_typecode (TypeCode &);
    virtual Boolean get_ior (IOR &);

    Boolean get_string_stl (string &);
    Boolean get_string_raw_stl (string &);
    virtual Boolean get_octets (void *, ULong len);

    virtual Boolean enumeration (ULong &);

    virtual Boolean struct_begin ();
    virtual Boolean struct_end ();

    virtual Boolean except_begin (string &repoid);
    virtual Boolean except_end ();

    virtual Boolean seq_begin (ULong &);
    virtual Boolean seq_end ();

    virtual Boolean encaps_begin (EncapsState &state, ULong &len);
    virtual Boolean encaps_end (EncapsState &state);

    virtual Boolean union_begin ();
    virtual Boolean union_end ();

    virtual Boolean arr_begin ();
    virtual Boolean arr_end ();

    virtual Boolean value_begin (string &url,
                                 vector<string> &repoids,
                                 Long &value_id,
                                 Boolean &is_ref,
                                 ValueState &state);
    Boolean value_begin (string &url,
                         vector<string> &repoids,
                         Long &value_id,
                         Boolean &is_ref);
    virtual Boolean value_end (Long value_id, ValueState &state);
    Boolean value_end (Long value_id);

    virtual ULong max_alignment () const = 0;

    Buffer *buffer ()
    { return buf; }

    void buffer (Buffer *, Boolean dofree = 1);

    virtual ByteOrder byteorder () const;
    virtual void byteorder (ByteOrder);

    CodeSetCoder *converter ()
    { return conv; }

    void converter (CodeSetCoder *, Boolean dofree = 1);

    ValueState *valuestate ()
    { return vstate; }

    void valuestate (ValueState *vs, Boolean dofree = 1);
};

}
# 189 "../include/CORBA.h" 2
# 1 "../include/mico/except.h" 1
# 29 "../include/mico/except.h"
namespace CORBA {

class Exception : public MagicChecker {

    static void (*_old_terminate_handler) ();
    static void _terminate_handler ();





public:
    Exception (const Exception &);
    virtual ~Exception ();
    Exception &operator= (const Exception &);

    virtual void _print (ostream &) const;
    virtual void _encode (DataEncoder &) const;
    virtual void _encode_any (Any &) const;
    virtual const char *_repoid () const;
    virtual Exception *_clone () const;





    void _raise ();
    virtual void _throwit () const;

    static Exception *_decode (Any &);
    static Exception *_decode (DataDecoder &);

    static void _throw_failed (const Exception *ex);
    static void _init ();
protected:
    Exception ();
};

enum {
    OMGVMCID = 0x4f4d0000
};

enum completion_status {
    COMPLETED_YES,
    COMPLETED_NO,
    COMPLETED_MAYBE
};

typedef completion_status CompletionStatus;

enum exception_type {
    NO_EXCEPTION,
    USER_EXCEPTION,
    SYSTEM_EXCEPTION
};

class SystemException : public Exception {
    ULong _minor;
    CompletionStatus _completed;
public:
    SystemException ();
    SystemException (const SystemException &);
    SystemException (ULong minor, CompletionStatus status);
    SystemException &operator= (const SystemException &);
    virtual ~SystemException ();


    SystemException *operator->() { return this; }
    SystemException& operator*() { return *this; }
    operator SystemException*() { return this; }


    ULong minor () const;
    void minor (ULong);

    CompletionStatus completed () const;
    void completed (CompletionStatus);

    virtual void _print (ostream &) const;
    virtual void _encode (DataEncoder &) const;
    virtual const char *_repoid () const;
    virtual Exception *_clone () const;
    virtual void _throwit() const;

    static SystemException *_downcast (Exception *);
    static const SystemException *_downcast (const Exception *);
    static SystemException *_decode (Any &);
    static SystemException *_decode (DataDecoder &);

    static SystemException *_create_sysex (const char *repoid, ULong minor,
                                           CompletionStatus status);
    static Boolean _is_sysex (const char *repoid);
};



typedef SystemException SystemException_catch;
# 134 "../include/mico/except.h"
class UserException : public Exception {
public:
    UserException ();
    UserException (const UserException &);
    UserException &operator= (const UserException &);
    virtual ~UserException ();

    virtual void _print (ostream &) const;
    virtual void _encode (DataEncoder &) const;
    virtual const char *_repoid () const;
    virtual Exception *_clone () const;
    virtual void _throwit () const;

    static UserException *_downcast (Exception *);
    static const UserException *_downcast (const Exception *);
    static UserException *_decode (Any &);
    static UserException *_decode (DataDecoder &);
};

class UnknownUserException : public UserException {
    Any *_excpt;
    StaticAny *_static_except;
    DataDecoder *_dc;
    string _ex_repoid;
public:
    UnknownUserException (Any *);
    UnknownUserException (DataDecoder *);
    UnknownUserException ();
    UnknownUserException (const UnknownUserException &);
    UnknownUserException &operator= (const UnknownUserException &);
    virtual ~UnknownUserException ();

    Any &exception (TypeCode_ptr = 0);
    StaticAny &exception (CORBA::StaticTypeInfo *);

    virtual void _throwit () const;
    virtual void _print (ostream &) const;
    virtual void _encode (DataEncoder &) const;
    virtual void _encode_any (Any &) const;
    virtual const char *_repoid () const;
    virtual const char *_except_repoid ();
    virtual Exception *_clone () const;

    static UnknownUserException *_downcast (Exception *);
    static const UnknownUserException *_downcast (const Exception *);
};
# 204 "../include/mico/except.h"
# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
class UNKNOWN : public SystemException { public: UNKNOWN (); UNKNOWN (const UNKNOWN &ex); UNKNOWN (ULong minor, CompletionStatus status); UNKNOWN &operator= (const UNKNOWN &ex); virtual ~UNKNOWN (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static UNKNOWN *_downcast (Exception *ex); static const UNKNOWN *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_UNKNOWN;
class BAD_PARAM : public SystemException { public: BAD_PARAM (); BAD_PARAM (const BAD_PARAM &ex); BAD_PARAM (ULong minor, CompletionStatus status); BAD_PARAM &operator= (const BAD_PARAM &ex); virtual ~BAD_PARAM (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static BAD_PARAM *_downcast (Exception *ex); static const BAD_PARAM *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_BAD_PARAM;
class NO_MEMORY : public SystemException { public: NO_MEMORY (); NO_MEMORY (const NO_MEMORY &ex); NO_MEMORY (ULong minor, CompletionStatus status); NO_MEMORY &operator= (const NO_MEMORY &ex); virtual ~NO_MEMORY (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static NO_MEMORY *_downcast (Exception *ex); static const NO_MEMORY *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_NO_MEMORY;
class IMP_LIMIT : public SystemException { public: IMP_LIMIT (); IMP_LIMIT (const IMP_LIMIT &ex); IMP_LIMIT (ULong minor, CompletionStatus status); IMP_LIMIT &operator= (const IMP_LIMIT &ex); virtual ~IMP_LIMIT (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static IMP_LIMIT *_downcast (Exception *ex); static const IMP_LIMIT *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_IMP_LIMIT;
class COMM_FAILURE : public SystemException { public: COMM_FAILURE (); COMM_FAILURE (const COMM_FAILURE &ex); COMM_FAILURE (ULong minor, CompletionStatus status); COMM_FAILURE &operator= (const COMM_FAILURE &ex); virtual ~COMM_FAILURE (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static COMM_FAILURE *_downcast (Exception *ex); static const COMM_FAILURE *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_COMM_FAILURE;
class INV_OBJREF : public SystemException { public: INV_OBJREF (); INV_OBJREF (const INV_OBJREF &ex); INV_OBJREF (ULong minor, CompletionStatus status); INV_OBJREF &operator= (const INV_OBJREF &ex); virtual ~INV_OBJREF (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INV_OBJREF *_downcast (Exception *ex); static const INV_OBJREF *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INV_OBJREF;
class NO_PERMISSION : public SystemException { public: NO_PERMISSION (); NO_PERMISSION (const NO_PERMISSION &ex); NO_PERMISSION (ULong minor, CompletionStatus status); NO_PERMISSION &operator= (const NO_PERMISSION &ex); virtual ~NO_PERMISSION (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static NO_PERMISSION *_downcast (Exception *ex); static const NO_PERMISSION *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_NO_PERMISSION;
class INTERNAL : public SystemException { public: INTERNAL (); INTERNAL (const INTERNAL &ex); INTERNAL (ULong minor, CompletionStatus status); INTERNAL &operator= (const INTERNAL &ex); virtual ~INTERNAL (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INTERNAL *_downcast (Exception *ex); static const INTERNAL *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INTERNAL;
class MARSHAL : public SystemException { public: MARSHAL (); MARSHAL (const MARSHAL &ex); MARSHAL (ULong minor, CompletionStatus status); MARSHAL &operator= (const MARSHAL &ex); virtual ~MARSHAL (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static MARSHAL *_downcast (Exception *ex); static const MARSHAL *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_MARSHAL;
class INITIALIZE : public SystemException { public: INITIALIZE (); INITIALIZE (const INITIALIZE &ex); INITIALIZE (ULong minor, CompletionStatus status); INITIALIZE &operator= (const INITIALIZE &ex); virtual ~INITIALIZE (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INITIALIZE *_downcast (Exception *ex); static const INITIALIZE *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INITIALIZE;
class NO_IMPLEMENT : public SystemException { public: NO_IMPLEMENT (); NO_IMPLEMENT (const NO_IMPLEMENT &ex); NO_IMPLEMENT (ULong minor, CompletionStatus status); NO_IMPLEMENT &operator= (const NO_IMPLEMENT &ex); virtual ~NO_IMPLEMENT (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static NO_IMPLEMENT *_downcast (Exception *ex); static const NO_IMPLEMENT *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_NO_IMPLEMENT;
class BAD_TYPECODE : public SystemException { public: BAD_TYPECODE (); BAD_TYPECODE (const BAD_TYPECODE &ex); BAD_TYPECODE (ULong minor, CompletionStatus status); BAD_TYPECODE &operator= (const BAD_TYPECODE &ex); virtual ~BAD_TYPECODE (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static BAD_TYPECODE *_downcast (Exception *ex); static const BAD_TYPECODE *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_BAD_TYPECODE;
class BAD_OPERATION : public SystemException { public: BAD_OPERATION (); BAD_OPERATION (const BAD_OPERATION &ex); BAD_OPERATION (ULong minor, CompletionStatus status); BAD_OPERATION &operator= (const BAD_OPERATION &ex); virtual ~BAD_OPERATION (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static BAD_OPERATION *_downcast (Exception *ex); static const BAD_OPERATION *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_BAD_OPERATION;
class NO_RESOURCES : public SystemException { public: NO_RESOURCES (); NO_RESOURCES (const NO_RESOURCES &ex); NO_RESOURCES (ULong minor, CompletionStatus status); NO_RESOURCES &operator= (const NO_RESOURCES &ex); virtual ~NO_RESOURCES (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static NO_RESOURCES *_downcast (Exception *ex); static const NO_RESOURCES *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_NO_RESOURCES;
class NO_RESPONSE : public SystemException { public: NO_RESPONSE (); NO_RESPONSE (const NO_RESPONSE &ex); NO_RESPONSE (ULong minor, CompletionStatus status); NO_RESPONSE &operator= (const NO_RESPONSE &ex); virtual ~NO_RESPONSE (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static NO_RESPONSE *_downcast (Exception *ex); static const NO_RESPONSE *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_NO_RESPONSE;
class PERSIST_STORE : public SystemException { public: PERSIST_STORE (); PERSIST_STORE (const PERSIST_STORE &ex); PERSIST_STORE (ULong minor, CompletionStatus status); PERSIST_STORE &operator= (const PERSIST_STORE &ex); virtual ~PERSIST_STORE (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static PERSIST_STORE *_downcast (Exception *ex); static const PERSIST_STORE *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_PERSIST_STORE;
class BAD_INV_ORDER : public SystemException { public: BAD_INV_ORDER (); BAD_INV_ORDER (const BAD_INV_ORDER &ex); BAD_INV_ORDER (ULong minor, CompletionStatus status); BAD_INV_ORDER &operator= (const BAD_INV_ORDER &ex); virtual ~BAD_INV_ORDER (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static BAD_INV_ORDER *_downcast (Exception *ex); static const BAD_INV_ORDER *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_BAD_INV_ORDER;
class TRANSIENT : public SystemException { public: TRANSIENT (); TRANSIENT (const TRANSIENT &ex); TRANSIENT (ULong minor, CompletionStatus status); TRANSIENT &operator= (const TRANSIENT &ex); virtual ~TRANSIENT (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static TRANSIENT *_downcast (Exception *ex); static const TRANSIENT *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_TRANSIENT;
class FREE_MEM : public SystemException { public: FREE_MEM (); FREE_MEM (const FREE_MEM &ex); FREE_MEM (ULong minor, CompletionStatus status); FREE_MEM &operator= (const FREE_MEM &ex); virtual ~FREE_MEM (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static FREE_MEM *_downcast (Exception *ex); static const FREE_MEM *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_FREE_MEM;
class INV_IDENT : public SystemException { public: INV_IDENT (); INV_IDENT (const INV_IDENT &ex); INV_IDENT (ULong minor, CompletionStatus status); INV_IDENT &operator= (const INV_IDENT &ex); virtual ~INV_IDENT (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INV_IDENT *_downcast (Exception *ex); static const INV_IDENT *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INV_IDENT;
class INV_FLAG : public SystemException { public: INV_FLAG (); INV_FLAG (const INV_FLAG &ex); INV_FLAG (ULong minor, CompletionStatus status); INV_FLAG &operator= (const INV_FLAG &ex); virtual ~INV_FLAG (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INV_FLAG *_downcast (Exception *ex); static const INV_FLAG *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INV_FLAG;
class INTF_REPOS : public SystemException { public: INTF_REPOS (); INTF_REPOS (const INTF_REPOS &ex); INTF_REPOS (ULong minor, CompletionStatus status); INTF_REPOS &operator= (const INTF_REPOS &ex); virtual ~INTF_REPOS (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INTF_REPOS *_downcast (Exception *ex); static const INTF_REPOS *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INTF_REPOS;
class BAD_CONTEXT : public SystemException { public: BAD_CONTEXT (); BAD_CONTEXT (const BAD_CONTEXT &ex); BAD_CONTEXT (ULong minor, CompletionStatus status); BAD_CONTEXT &operator= (const BAD_CONTEXT &ex); virtual ~BAD_CONTEXT (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static BAD_CONTEXT *_downcast (Exception *ex); static const BAD_CONTEXT *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_BAD_CONTEXT;
class OBJ_ADAPTER : public SystemException { public: OBJ_ADAPTER (); OBJ_ADAPTER (const OBJ_ADAPTER &ex); OBJ_ADAPTER (ULong minor, CompletionStatus status); OBJ_ADAPTER &operator= (const OBJ_ADAPTER &ex); virtual ~OBJ_ADAPTER (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static OBJ_ADAPTER *_downcast (Exception *ex); static const OBJ_ADAPTER *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_OBJ_ADAPTER;
class DATA_CONVERSION : public SystemException { public: DATA_CONVERSION (); DATA_CONVERSION (const DATA_CONVERSION &ex); DATA_CONVERSION (ULong minor, CompletionStatus status); DATA_CONVERSION &operator= (const DATA_CONVERSION &ex); virtual ~DATA_CONVERSION (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static DATA_CONVERSION *_downcast (Exception *ex); static const DATA_CONVERSION *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_DATA_CONVERSION;
class OBJECT_NOT_EXIST : public SystemException { public: OBJECT_NOT_EXIST (); OBJECT_NOT_EXIST (const OBJECT_NOT_EXIST &ex); OBJECT_NOT_EXIST (ULong minor, CompletionStatus status); OBJECT_NOT_EXIST &operator= (const OBJECT_NOT_EXIST &ex); virtual ~OBJECT_NOT_EXIST (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static OBJECT_NOT_EXIST *_downcast (Exception *ex); static const OBJECT_NOT_EXIST *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_OBJECT_NOT_EXIST;
class TRANSACTION_REQUIRED : public SystemException { public: TRANSACTION_REQUIRED (); TRANSACTION_REQUIRED (const TRANSACTION_REQUIRED &ex); TRANSACTION_REQUIRED (ULong minor, CompletionStatus status); TRANSACTION_REQUIRED &operator= (const TRANSACTION_REQUIRED &ex); virtual ~TRANSACTION_REQUIRED (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static TRANSACTION_REQUIRED *_downcast (Exception *ex); static const TRANSACTION_REQUIRED *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_TRANSACTION_REQUIRED;
class TRANSACTION_ROLLEDBACK : public SystemException { public: TRANSACTION_ROLLEDBACK (); TRANSACTION_ROLLEDBACK (const TRANSACTION_ROLLEDBACK &ex); TRANSACTION_ROLLEDBACK (ULong minor, CompletionStatus status); TRANSACTION_ROLLEDBACK &operator= (const TRANSACTION_ROLLEDBACK &ex); virtual ~TRANSACTION_ROLLEDBACK (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static TRANSACTION_ROLLEDBACK *_downcast (Exception *ex); static const TRANSACTION_ROLLEDBACK *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_TRANSACTION_ROLLEDBACK;
class INVALID_TRANSACTION : public SystemException { public: INVALID_TRANSACTION (); INVALID_TRANSACTION (const INVALID_TRANSACTION &ex); INVALID_TRANSACTION (ULong minor, CompletionStatus status); INVALID_TRANSACTION &operator= (const INVALID_TRANSACTION &ex); virtual ~INVALID_TRANSACTION (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INVALID_TRANSACTION *_downcast (Exception *ex); static const INVALID_TRANSACTION *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INVALID_TRANSACTION;
class INV_POLICY : public SystemException { public: INV_POLICY (); INV_POLICY (const INV_POLICY &ex); INV_POLICY (ULong minor, CompletionStatus status); INV_POLICY &operator= (const INV_POLICY &ex); virtual ~INV_POLICY (); virtual const char *_repoid () const; virtual Exception *_clone () const; virtual void _encode_any (Any &) const; virtual void _throwit () const; static INV_POLICY *_downcast (Exception *ex); static const INV_POLICY *_downcast (const Exception *ex); }; extern TypeCode_ptr _tc_INV_POLICY;
# 205 "../include/mico/except.h" 2




}
# 190 "../include/CORBA.h" 2
# 1 "../include/mico/orb_excepts.h" 1
# 12 "../include/mico/orb_excepts.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/orb_excepts.h" 2



namespace CORBA {





struct Bounds : public UserException {
# 32 "../include/mico/orb_excepts.h"
  Bounds *operator->() { return this; }
  Bounds& operator*() { return *this; }
  operator Bounds*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static Bounds *_downcast( CORBA::Exception *ex );
  static const Bounds *_downcast( const CORBA::Exception *ex );
};


typedef Bounds Bounds_catch;






struct WrongTransaction : public UserException {
# 64 "../include/mico/orb_excepts.h"
  WrongTransaction *operator->() { return this; }
  WrongTransaction& operator*() { return *this; }
  operator WrongTransaction*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static WrongTransaction *_downcast( CORBA::Exception *ex );
  static const WrongTransaction *_downcast( const CORBA::Exception *ex );
};


typedef WrongTransaction WrongTransaction_catch;






struct ORB_InvalidName : public UserException {
# 96 "../include/mico/orb_excepts.h"
  ORB_InvalidName *operator->() { return this; }
  ORB_InvalidName& operator*() { return *this; }
  operator ORB_InvalidName*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ORB_InvalidName *_downcast( CORBA::Exception *ex );
  static const ORB_InvalidName *_downcast( const CORBA::Exception *ex );
};


typedef ORB_InvalidName ORB_InvalidName_catch;






struct TypeCode_Bounds : public UserException {
# 128 "../include/mico/orb_excepts.h"
  TypeCode_Bounds *operator->() { return this; }
  TypeCode_Bounds& operator*() { return *this; }
  operator TypeCode_Bounds*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static TypeCode_Bounds *_downcast( CORBA::Exception *ex );
  static const TypeCode_Bounds *_downcast( const CORBA::Exception *ex );
};


typedef TypeCode_Bounds TypeCode_Bounds_catch;






struct TypeCode_BadKind : public UserException {
# 160 "../include/mico/orb_excepts.h"
  TypeCode_BadKind *operator->() { return this; }
  TypeCode_BadKind& operator*() { return *this; }
  operator TypeCode_BadKind*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static TypeCode_BadKind *_downcast( CORBA::Exception *ex );
  static const TypeCode_BadKind *_downcast( const CORBA::Exception *ex );
};


typedef TypeCode_BadKind TypeCode_BadKind_catch;
# 186 "../include/mico/orb_excepts.h"
}
# 201 "../include/mico/orb_excepts.h"
# 1 "../include/mico/template_impl.h" 1
# 202 "../include/mico/orb_excepts.h" 2
# 191 "../include/CORBA.h" 2
# 1 "../include/mico/any.h" 1
# 27 "../include/mico/any.h"
namespace CORBA {

class Any {
    typedef map<Long, Long, less<Long> > MapLL;

    TypeCodeChecker *checker;
    DataEncoder *ec;
    DataDecoder *dc;
    TypeCode_ptr thetc;
    DataEncoder::ValueState value_estate;
    DataDecoder::ValueState value_dstate;
    StaticAny *extracted_value;

    TypeCode_ptr tc () const;
    void tc (TypeCode_ptr);
    void tc_if_changed (TypeCode_ptr);

    void free ();
    void copy (const Any &);
    void reset_extracted_value ();

    void prepare_write ();
    void prepare_read ();
    Boolean copy_any (Any &, MapLL &value_id_map, Boolean recurse = 1);
    Boolean copy_any (Any &, Boolean recurse = 1);
    Boolean compare_any (Any &, MapLL &value_id_map);
    Boolean compare_any (Any &);


    Any (TypeCode_ptr tc, Buffer *, Boolean release, int dummy);
    Any (TypeCode_ptr tc, DataDecoder *, DataEncoder *);

    Boolean get_short (Short &);
    Boolean get_ushort (UShort &);
    Boolean get_long (Long &);
    Boolean get_longlong (LongLong &);
    Boolean get_ulong (ULong &);
    Boolean get_ulonglong (ULongLong &);
    Boolean get_float (Float &);
    Boolean get_double (Double &);
    Boolean get_longdouble (LongDouble &);
public:
    Any ();
    Any (const Any &);
    Any (TypeCode_ptr tc, void *value, Boolean release = 0);
    ~Any ();

    Any &operator= (const Any &);

    Boolean operator== (const Any &) const;
    Boolean equivalent (const Any &) const;


    struct from_boolean {
        from_boolean (Boolean b) : val (b) {}
        Boolean val;
    };
    struct from_octet {
        from_octet (Octet o) : val (o) {}
        Octet val;
    };
    struct from_char {
        from_char (Char c) : val (c) {}
        Char val;
    };
    struct from_wchar {
        from_wchar (WChar c) : val (c) {}
        WChar val;
    };
    struct from_string {
        from_string (char *s, ULong b, Boolean nc = 0)
            : val (s), bound (b), nocopy (nc) {}
        from_string (const char *s, ULong b)
            : val ((char *)s), bound (b), nocopy (0) {}
        char *val;
        ULong bound;
        Boolean nocopy;
    };
    struct from_wstring {
        from_wstring (wchar_t *s, ULong b, Boolean nc = 0)
            : val (s), bound (b), nocopy (nc) {}
        from_wstring (const wchar_t *s, ULong b)
            : val ((wchar_t *)s), bound (b), nocopy (0) {}
        wchar_t *val;
        ULong bound;
        Boolean nocopy;
    };
    struct from_fixed {
        from_fixed (const Fixed &f, UShort d, Short s)
            : fixed (f), digits (d), scale (s) {}
        const Fixed &fixed;
        UShort digits;
        Short scale;
    };

    struct from_object {
        from_object (Object_ptr o, const char *n) : name (n), val (o) {}
        const char *name;
        Object_ptr val;
    };


    void operator<<= (Short);
    void operator<<= (Long);
    void operator<<= (LongLong);
    void operator<<= (UShort);
    void operator<<= (ULong);
    void operator<<= (ULongLong);
    void operator<<= (Float);
    void operator<<= (Double);
    void operator<<= (LongDouble);
    void operator<<= (const Any &);
    void operator<<= (Any *);
    void operator<<= (const Exception &);
    void operator<<= (Exception *);
    void operator<<= (const char *);
    void operator<<= (const wchar_t *);
    void operator<<= (from_boolean);
    void operator<<= (from_octet);
    void operator<<= (from_char);
    void operator<<= (from_wchar);
    void operator<<= (from_string);
    void operator<<= (from_wstring);

    void operator<<= (from_fixed);
    void operator<<= (from_object);
    void operator<<= (Object_ptr);
    void operator<<= (Object_ptr*);
    void operator<<= (TypeCode_ptr);
    void operator<<= (TypeCode_ptr*);
    void operator<<= (Context_ptr);
    void operator<<= (Context_ptr*);
    void operator<<= (Principal_ptr);
    void operator<<= (Principal_ptr*);

    Boolean insert (Short);
    Boolean insert (Long);
    Boolean insert (LongLong);
    Boolean insert (UShort);
    Boolean insert (ULong);
    Boolean insert (ULongLong);
    Boolean insert (Float);
    Boolean insert (Double);
    Boolean insert (LongDouble);
    Boolean insert (const Any &);
    Boolean insert (Any *);
    Boolean insert (const Exception &);
    Boolean insert (Exception *);
    Boolean insert (const char *);
    Boolean insert (const wchar_t *);
    Boolean insert (from_boolean);
    Boolean insert (from_octet);
    Boolean insert (from_char);
    Boolean insert (from_wchar);
    Boolean insert (from_string);
    Boolean insert (from_wstring);
    Boolean insert (from_fixed);
    Boolean insert (from_object);
    Boolean insert (Object_ptr);
    Boolean insert (Object_ptr*);
    Boolean insert (TypeCode_ptr);
    Boolean insert (TypeCode_ptr*);
    Boolean insert (Context_ptr);
    Boolean insert (Context_ptr*);
    Boolean insert (Principal_ptr);
    Boolean insert (Principal_ptr*);


    struct to_boolean {
        to_boolean (Boolean &b) : ref (b) {}
        Boolean &ref;
    };
    struct to_octet {
        to_octet (Octet &o) : ref (o) {}
        Octet &ref;
    };
    struct to_char {
        to_char (Char &c) : ref (c) {}
        Char &ref;
    };
    struct to_wchar {
        to_wchar (WChar &c) : ref (c) {}
        WChar &ref;
    };
    struct to_string {
        to_string (const char * &s, ULong b) : ref (s), bound (b) {}
        const char * &ref;
        ULong bound;
    };
    struct to_wstring {
        to_wstring (const wchar_t * &s, ULong b) : ref (s), bound (b) {}
        const wchar_t * &ref;
        ULong bound;
    };
    struct to_object {
        to_object (Object_out o)
            : ref (o.ptr()), name (0) {}
        to_object (Object_out o, String_out n)
            : ref (o.ptr()), name (&n.ptr()) {}
        Object_ptr &ref;
        char **name;
    };
    struct to_fixed {
        to_fixed (Fixed &f, UShort d, Short s)
            : fixed (f), digits (d), scale (s) {}
        Fixed &fixed;
        UShort digits;
        Short scale;
    };
    struct to_abstract_base {
        to_abstract_base (AbstractBase *& base)
          : ref (base) {}
        AbstractBase *& ref;
    };

    Boolean operator>>= (Short &) const;
    Boolean operator>>= (Long &) const;
    Boolean operator>>= (LongLong &) const;
    Boolean operator>>= (UShort &) const;
    Boolean operator>>= (ULong &) const;
    Boolean operator>>= (ULongLong &) const;
    Boolean operator>>= (Float &) const;
    Boolean operator>>= (Double &) const;
    Boolean operator>>= (LongDouble &) const;
    Boolean operator>>= (const Any *&) const;
    Boolean operator>>= (const char * &) const;
    Boolean operator>>= (const wchar_t * &) const;
    Boolean operator>>= (to_boolean) const;
    Boolean operator>>= (to_octet) const;
    Boolean operator>>= (to_char) const;
    Boolean operator>>= (to_wchar) const;
    Boolean operator>>= (to_string) const;
    Boolean operator>>= (to_wstring) const;
    Boolean operator>>= (to_object) const;
    Boolean operator>>= (to_abstract_base) const;

    Boolean operator>>= (to_fixed) const;
    Boolean operator>>= (Object_ptr &) const;
    Boolean operator>>= (TypeCode_ptr &) const;
    Boolean operator>>= (Context_ptr &) const;
    Boolean operator>>= (Principal_ptr &) const;


    void replace (TypeCode_ptr tc, void *value, Boolean release = 0);


    void replace (TypeCode_ptr tc);

    const void *value () const;
    TypeCode_ptr type () const;
    void type (TypeCode_ptr);

    ULong length () const;
    void set_type (TypeCode_ptr);
    void reset ();
    void rewind ();

    void encode (DataEncoder &) const;
    Boolean decode (DataDecoder &);

    Boolean marshal (DataEncoder &);
    Boolean demarshal (TypeCode_ptr, DataDecoder &);

    Boolean from_static_any (const StaticAny &);
    Boolean from_static_any (const StaticAny &, TypeCode_ptr);
    Boolean to_static_any (StaticAny &) const;
    Boolean to_static_any (StaticTypeInfo *ti, void *&value) const;
    Boolean to_static_any (StaticTypeInfo *ti, CORBA::TypeCode_ptr,
                           void *&value) const;
    Boolean to_static_any (StaticAny &, TypeCode_ptr) const;

    Boolean coerce (CORBA::Any &dst) const;




    Boolean struct_put_begin ();
    Boolean struct_put_end ();

    Boolean union_put_begin ();
    Boolean union_put_selection (Long idx);
    Boolean union_put_end ();

    Boolean enum_put (ULong val);
    Boolean any_put (Any &, Boolean recurse = 1);

    Boolean seq_put_begin (ULong len);
    Boolean seq_put_end ();

    Boolean array_put_begin ();
    Boolean array_put_end ();

    Boolean except_put_begin (const char *repoid);
    Boolean except_put_end ();

    Boolean value_put_begin (Long &value_id);
    Boolean value_put_end (Long value_id);
    Boolean value_put_ref (Long value_id);

    Boolean valuebox_put_begin (Long &value_id);
    Boolean valuebox_put_end (Long value_id);
    Boolean valuebox_put_ref (Long value_id);


    Boolean struct_get_begin () const;
    Boolean struct_get_end () const;

    Boolean union_get_begin () const;
    Boolean union_get_selection (Long idx) const;
    Boolean union_get_end () const;

    Boolean enum_get (ULong &val) const;
    Boolean any_get (Any &, Boolean recurse = 1) const;

    Boolean seq_get_begin (ULong &len) const;
    Boolean seq_get_end () const;

    Boolean array_get_begin () const;
    Boolean array_get_end () const;

    Boolean except_get_begin (String_out repoid) const;
    Boolean except_get_end () const;

    Boolean value_get_begin (Long &value_id, Boolean &is_ref) const;
    Boolean value_get_end (Long value_id, Boolean is_ref) const;

    Boolean valuebox_get_begin (Long &value_id, Boolean &is_ref) const;
    Boolean valuebox_get_end (Long value_id, Boolean is_ref) const;


private:
    void operator<<= (unsigned char) {}
    void operator>>= (unsigned char &) const {}
};

typedef TVarVar<Any> Any_var;
typedef TVarOut<Any> Any_out;

}
# 192 "../include/CORBA.h" 2
# 1 "../include/mico/object.h" 1
# 27 "../include/mico/object.h"
namespace CORBA {


class ServerlessObject : public MagicChecker {
    Long refs;
public:
    virtual ~ServerlessObject ();

    void _ref ();
    Boolean _deref ();
    Long _refcnt () const;

    static ServerlessObject* _nil ()
    {
        return 0;
    }
    static ServerlessObject* _duplicate (ServerlessObject *o)
    {
        if (o)
            o->_ref();
        return o;
    }
protected:
    ServerlessObject ()
    { refs = 1; }

    ServerlessObject (const ServerlessObject &so)
        : CORBA::MagicChecker (so)
    { refs = 1; }

    ServerlessObject &operator= (const ServerlessObject &)
    { return *this; }
};

typedef ServerlessObject *ServerlessObject_ptr;
typedef ObjVar<ServerlessObject> ServerlessObject_var;
typedef ObjOut<ServerlessObject> ServerlessObject_out;

static inline void release (ServerlessObject *o)
{
    if (o && o->_deref())
        delete o;
}

static inline Boolean is_nil (ServerlessObject *o)
{
    return !o;
}



class Policy;
typedef Policy *Policy_ptr;
typedef ObjVar<Policy> Policy_var;
typedef ObjOut<Policy> Policy_out;
typedef IfaceSequenceTmpl<CORBA::Policy_var,CORBA::Policy_ptr> PolicyList;

class DomainManager;
typedef DomainManager *DomainManager_ptr;
typedef ObjVar<DomainManager> DomainManager_var;
typedef ObjOut<DomainManager> DomainManager_out;
typedef IfaceSequenceTmpl<CORBA::DomainManager_var,CORBA::DomainManager_ptr> DomainManagerList;

typedef CORBA::ULong PolicyType;

enum SetOverrideType {
    SET_OVERRIDE,
    ADD_OVERRIDE
};


class Object : public ServerlessObject {
    IOR *ior;
    IOR *fwd_ior;
    ORB_ptr orb;
    string ident;
protected:
    DomainManagerList _managers;
    PolicyList _policies;
public:
    ImplementationDef *_get_implementation ();
    InterfaceDef *_get_interface ();

    void _create_request (Context_ptr ctx,
                          const char *operation,
                          NVList_ptr arg_list,
                          NamedValue_ptr result,
                          Request_out request,
                          Flags req_flags);

    void _create_request (Context_ptr ctx,
                          const char *operation,
                          NVList_ptr arg_list,
                          NamedValue_ptr result,
                          ExceptionList_ptr,
                          ContextList_ptr,
                          Request_out request,
                          Flags req_flags);

    Request_ptr _request (const char *operation);

    Policy_ptr _get_policy (PolicyType policy_type);
    DomainManagerList *_get_domain_managers ();
    Object_ptr _set_policy_overrides (const PolicyList &policies,
                                      SetOverrideType set_add);


    Boolean _is_a (const char *logical_type_id);
    Boolean _is_a_remote (const char *logical_type_id);
    Boolean _non_existent ();
    Boolean _is_equivalent (Object_ptr);
    ULong _hash (ULong max);



    Object (IOR * = 0);
    Object (const Object &);
    Object &operator= (const Object &);
    virtual ~Object ();

    void _setup_domains (CORBA::Object_ptr parent);

    void _forward (CORBA::Object_ptr);
    void _unforward ();
    Boolean _is_forwarded ()
    { return !!fwd_ior; }

    ORB_ptr _orbnc ()
    { return orb; }

    IOR *_ior ()
    { return ior; }

    IOR *_ior_fwd ()
    { return fwd_ior ? fwd_ior : ior; }

    const char *_repoid ()
    { return ior->objid(); }

    const char *_ident ();
    virtual void *_narrow_helper (const char *repoid);


    static Object_ptr _duplicate (Object_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static Object_ptr _nil ()
    {
        return 0;
    }
};

class LocalObject : public Object {
};

typedef ObjVar<Object> Object_var;



extern Object_ptr OBJECT_NIL;


typedef bool (*Narrow_proto) (Object_ptr);

}
# 193 "../include/CORBA.h" 2
# 1 "../include/mico/value.h" 1
# 27 "../include/mico/value.h"
namespace CORBA {

class ValueBase {
protected:

    static ValueBase *_create (const vector<string> &repoids,
                               const string &myrepoid);

public:
    virtual void _add_ref () = 0;
    virtual void _remove_ref () = 0;
    virtual ULong _refcount_value () = 0;
    virtual ValueBase *_copy_value ();
    virtual ValueDef_ptr get_value_def () = 0;

    static ValueBase *_downcast (ValueBase *);


    static void _marshal (DataEncoder &ec, ValueBase *vb);
    static Boolean _demarshal (DataDecoder &dc, ValueBase *&vb,
                               const string &myrepoid);
    virtual void * _narrow_helper (const char *);


protected:
    ValueBase ();
    ValueBase (const ValueBase &);
    virtual ~ValueBase ();


    virtual void _get_marshal_info (vector<string> &repoids,
                                    Boolean &chunked);
    virtual void _marshal_members (DataEncoder &ec);
    virtual Boolean _demarshal_members (DataDecoder &dc);


public:

    typedef set<ValueBase *, less<ValueBase *> > visited;
    virtual Long _count_refs (visited * = 0);
    virtual void _release_members ();
    bool _destructing;

private:
    void operator= (const ValueBase&);
};

typedef ValueVar<ValueBase> ValueBase_var;
typedef ValueOut<ValueBase> ValueBase_out;

static inline void add_ref (ValueBase *vb)
{
    if (vb)
        vb->_add_ref();
}

static inline void remove_ref (ValueBase *vb)
{
    if (vb)
        vb->_remove_ref();
}

class DefaultValueRefCountBase :
  virtual public ServerlessObject,
  virtual public ValueBase
{
public:
  DefaultValueRefCountBase ();
  virtual ~DefaultValueRefCountBase ();

  void _add_ref () { _ref(); }
  void _remove_ref () {
    if (_deref()) {
      delete this;
    }
    else if (!_destructing && _count_refs () == -1) {

      _add_ref ();
      _release_members ();
      delete this;
    }
  }
  ULong _refcount_value () { return _refcnt(); }

private:
  void operator= (const DefaultValueRefCountBase &);
};
# 123 "../include/mico/value.h"
class SimpleValueRefCountBase :
  virtual public ServerlessObject,
  virtual public ValueBase
{
public:
  SimpleValueRefCountBase ();
  virtual ~SimpleValueRefCountBase ();

  void _add_ref () { _ref(); }
  void _remove_ref () {
    if (_deref()) {
      delete this;
    }
  }
  ULong _refcount_value () { return _refcnt(); }

private:
  void operator= (const SimpleValueRefCountBase &);
};


class ValueFactoryBase;
typedef ValueFactoryBase *ValueFactory;
typedef ValueVar<ValueFactoryBase> ValueFactoryBase_var;

class ValueFactoryBase : public ServerlessObject {
public:
    virtual ~ValueFactoryBase ();

    virtual void _add_ref () { _ref(); }
    virtual void _remove_ref () { if (_deref()) delete this; }

    static ValueFactory _downcast (ValueFactory);


    virtual void * _narrow_helper (const char *);


protected:
    ValueFactoryBase ();


public:
    virtual ValueBase *create_for_unmarshal () = 0;
};



class AbstractBase;
typedef AbstractBase *AbstractBase_ptr;

class AbstractBase {
public:
  virtual ~AbstractBase () = 0;

  static AbstractBase_ptr _nil ()
  {
    return 0;
  }
  static AbstractBase_ptr _duplicate (AbstractBase_ptr);
  static AbstractBase_ptr _narrow (AbstractBase_ptr);


  virtual Object_ptr _to_object ();
  virtual ValueBase * _to_value ();
  static void _marshal (DataEncoder &ec, AbstractBase *vb);
  static Boolean _demarshal (DataDecoder &dc, AbstractBase *&vb);
  virtual void * _narrow_helper (const char *);


protected:
  AbstractBase ();
  AbstractBase (const AbstractBase &);
};

typedef ObjVar<AbstractBase> AbstractBase_var;
typedef AbstractBase_var AbstractBase_out;

extern void release (AbstractBase_ptr);
static inline Boolean is_nil (AbstractBase_ptr ab)
{
  return !ab;
}







class MixedBase :
  virtual public AbstractBase,
  virtual public Object
{
public:
  virtual ~MixedBase () = 0;
};

static inline void release (MixedBase *mb)
{
  CORBA::release ((Object_ptr) mb);
}

static inline Boolean is_nil (MixedBase *mb)
{
  return CORBA::is_nil ((Object_ptr) mb);
}







class UnknownAbstract : virtual public AbstractBase
{
public:
  UnknownAbstract (Object_ptr, ValueBase *);
  ~UnknownAbstract ();

  Object_ptr _to_object ();
  ValueBase * _to_value ();
  void * _narrow_helper (const char *);

private:
  Object_var obj;
  ValueBase_var val;
};

}
# 194 "../include/CORBA.h" 2
# 1 "../include/mico/basic_seq.h" 1
# 28 "../include/mico/basic_seq.h"
namespace CORBA {




typedef SequenceTmpl<CORBA::Any,0> AnySeq;



typedef TSeqVar<SequenceTmpl<CORBA::Any,0> > AnySeq_var;
typedef AnySeq_var AnySeq_out;

typedef SequenceTmpl<CORBA::Boolean,1> BooleanSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Boolean,1> > BooleanSeq_var;
typedef BooleanSeq_var BooleanSeq_out;

typedef SequenceTmpl<CORBA::Char,2> CharSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Char,2> > CharSeq_var;
typedef CharSeq_var CharSeq_out;

typedef SequenceTmpl<CORBA::WChar,4> WCharSeq;



typedef TSeqVar<SequenceTmpl<CORBA::WChar,4> > WCharSeq_var;
typedef WCharSeq_var WCharSeq_out;

typedef SequenceTmpl<CORBA::Octet,3> OctetSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Octet,3> > OctetSeq_var;
typedef OctetSeq_var OctetSeq_out;

typedef SequenceTmpl<CORBA::Short,0> ShortSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Short,0> > ShortSeq_var;
typedef ShortSeq_var ShortSeq_out;

typedef SequenceTmpl<CORBA::UShort,0> UShortSeq;



typedef TSeqVar<SequenceTmpl<CORBA::UShort,0> > UShortSeq_var;
typedef UShortSeq_var UShortSeq_out;

typedef SequenceTmpl<CORBA::Long,0> LongSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Long,0> > LongSeq_var;
typedef LongSeq_var LongSeq_out;

typedef SequenceTmpl<CORBA::ULong,0> ULongSeq;



typedef TSeqVar<SequenceTmpl<CORBA::ULong,0> > ULongSeq_var;
typedef ULongSeq_var ULongSeq_out;

typedef SequenceTmpl<CORBA::LongLong,0> LongLongSeq;



typedef TSeqVar<SequenceTmpl<CORBA::LongLong,0> > LongLongSeq_var;
typedef LongLongSeq_var LongLongSeq_out;

typedef SequenceTmpl<CORBA::ULongLong,0> ULongLongSeq;



typedef TSeqVar<SequenceTmpl<CORBA::ULongLong,0> > ULongLongSeq_var;
typedef ULongLongSeq_var ULongLongSeq_out;

typedef SequenceTmpl<CORBA::Float,0> FloatSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Float,0> > FloatSeq_var;
typedef FloatSeq_var FloatSeq_out;

typedef SequenceTmpl<CORBA::Double,0> DoubleSeq;



typedef TSeqVar<SequenceTmpl<CORBA::Double,0> > DoubleSeq_var;
typedef DoubleSeq_var DoubleSeq_out;





}




void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Any,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Any,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Any,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Any,0> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Char,2> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Char,2> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Char,2> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Char,2> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Boolean,1> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Boolean,1> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Boolean,1> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Boolean,1> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Octet,3> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Octet,3> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Octet,3> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Octet,3> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::UShort,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::UShort,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::UShort,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::UShort,0> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::ULong,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::ULong,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::ULong,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::ULong,0> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Short,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Short,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Short,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Short,0> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Long,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Long,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Long,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Long,0> *&s );

void operator<<=( CORBA::Any &_a,
                  const SequenceTmpl<CORBA::LongLong,0> &_s );
void operator<<=( CORBA::Any &_a,
                  SequenceTmpl<CORBA::LongLong,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            SequenceTmpl<CORBA::LongLong,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const SequenceTmpl<CORBA::LongLong,0> *&_s );

void operator<<=( CORBA::Any &_a,
                  const SequenceTmpl<CORBA::ULongLong,0> &_s );
void operator<<=( CORBA::Any &_a,
                  SequenceTmpl<CORBA::ULongLong,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            SequenceTmpl<CORBA::ULongLong,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const SequenceTmpl<CORBA::ULongLong,0> *&_s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Float,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Float,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Float,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Float,0> *&s );

void operator<<=( CORBA::Any &a,
                  const SequenceTmpl<CORBA::Double,0> &s );
void operator<<=( CORBA::Any &a,
                  SequenceTmpl<CORBA::Double,0> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            SequenceTmpl<CORBA::Double,0> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const SequenceTmpl<CORBA::Double,0> *&s );

void operator<<=( CORBA::Any &_a,
                  const SequenceTmpl<CORBA::LongDouble,0> &_s );
void operator<<=( CORBA::Any &_a,
                  SequenceTmpl<CORBA::LongDouble,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            SequenceTmpl<CORBA::LongDouble,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const SequenceTmpl<CORBA::LongDouble,0> *&_s );

void operator<<=( CORBA::Any &_a,
                  const SequenceTmpl<CORBA::WChar,4> &_s );
void operator<<=( CORBA::Any &_a,
                  SequenceTmpl<CORBA::WChar,4> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            SequenceTmpl<CORBA::WChar,4> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const SequenceTmpl<CORBA::WChar,4> *&_s );

void operator<<=( CORBA::Any &_a,
                  const WStringSequenceTmpl<CORBA::WString_var> &_s );
void operator<<=( CORBA::Any &_a,
                  WStringSequenceTmpl<CORBA::WString_var> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            WStringSequenceTmpl<CORBA::WString_var> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const WStringSequenceTmpl<CORBA::WString_var> *&_s );

void operator<<=( CORBA::Any &a,
                  const StringSequenceTmpl<CORBA::String_var> &s );
void operator<<=( CORBA::Any &a,
                  StringSequenceTmpl<CORBA::String_var> *s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            StringSequenceTmpl<CORBA::String_var> &s );
CORBA::Boolean operator>>=( const CORBA::Any &a,
                            const StringSequenceTmpl<CORBA::String_var> *&s );

void operator<<=( CORBA::Any &_a,
                  const IfaceSequenceTmpl<CORBA::Object_var, CORBA::Object_ptr> &_s );
void operator<<=( CORBA::Any &_a,
                  IfaceSequenceTmpl<CORBA::Object_var, CORBA::Object_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            IfaceSequenceTmpl<CORBA::Object_var,
                                              CORBA::Object_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a,
                            const IfaceSequenceTmpl<CORBA::Object_var,
                                              CORBA::Object_ptr> *&_s );
# 195 "../include/CORBA.h" 2
# 1 "../include/mico/orb_fwd.h" 1
# 27 "../include/mico/orb_fwd.h"
namespace CORBA {

enum InvokeStatus {
    InvokeOk,
    InvokeForward,
    InvokeSysEx,
    InvokeUsrEx,
    InvokeAddrDisp
};

enum LocateStatus {
    LocateUnknown,
    LocateHere,
    LocateForward,
    LocateAddrDisp
};

enum RequestType {
    RequestInvoke,
    RequestBind,
    RequestLocate,
    RequestUnknown
};

class ORBRequest;

struct ORBCallback {
    enum Event { Invoke, Locate, Bind };
    virtual void callback (ORB_ptr, ULong, Event) = 0;
    virtual ~ORBCallback ();
};

class ORBRequest : public ServerlessObject {
protected:
    CORBA::IOP::ServiceContextList _svc;
    void copy_svc (ORBRequest *r)
    { _svc = r->_svc; }
public:
    typedef vector<StaticAny *> StaticAnyList;

    virtual ~ORBRequest ();

    CORBA::IOP::ServiceContextList *context ()
    { return &_svc; }

    void context (CORBA::IOP::ServiceContextList *svc)
    { _svc = *svc; }

    virtual const char *op_name() = 0;

    virtual CORBA::Boolean get_in_args (NVList_ptr iparams,
                                        Context_ptr &ctx) = 0;
    virtual CORBA::Boolean get_in_args (StaticAnyList *iparams,
                                        Context_ptr &ctx)=0;
    virtual CORBA::Boolean get_in_args (DataEncoder *) = 0;

    virtual CORBA::Boolean get_out_args (Any *res, NVList_ptr oparams,
                                         Exception *&ex) = 0;
    virtual CORBA::Boolean get_out_args (StaticAny *res,
                                         StaticAnyList *oparams,
                                         Exception *&ex) = 0;
    virtual CORBA::Boolean get_out_args (DataEncoder *,
                                         Boolean &is_except) = 0;

    virtual CORBA::Boolean set_out_args (Any *res, NVList_ptr oparams) = 0;
    virtual CORBA::Boolean set_out_args (StaticAny *res,
                                         StaticAnyList *oparams) = 0;
    virtual void set_out_args (Exception *ex) = 0;
    virtual CORBA::Boolean set_out_args (DataDecoder *, Boolean is_except) = 0;

    virtual CORBA::Boolean copy_out_args (ORBRequest *) = 0;
    virtual CORBA::Boolean copy_in_args (ORBRequest *) = 0;

    virtual const char *type () = 0;

    static ORBRequest* _nil ()
    {
        return 0;
    }
    static ORBRequest* _duplicate (ORBRequest *o)
    {
        if (o)
            o->_ref();
        return o;
    }
};

}
# 196 "../include/CORBA.h" 2

# 1 "../include/mico/dii.h" 1
# 27 "../include/mico/dii.h"
namespace CORBA {


class Environment : public ServerlessObject {
    Exception *_exceptn;
    Principal_ptr _princ;
public:
    void exception (Exception *);
    Exception *exception () const
    { return _exceptn; }

    void clear ();


    Environment (Principal_ptr = __null);
    ~Environment ();

    Principal_ptr principal ()
    { return _princ; }


    static Environment_ptr _duplicate (Environment_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static Environment_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<Environment> Environment_var;



class NamedValue : public ServerlessObject {
    String_var _n;
    Any _v;
    Flags _f;
public:
    const char *name () const
    { return _n.in(); }

    Any *value () const
    { return (Any *)&_v; }

    Flags flags () const
    { return _f; }


    NamedValue (const char *name, const Any &, Flags f = 0);
    NamedValue (const char *name, Flags f = 0);
    NamedValue ();
    NamedValue &operator= (const NamedValue &);
    ~NamedValue ();


    static NamedValue_ptr _duplicate (NamedValue_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static NamedValue_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<NamedValue> NamedValue_var;
typedef ObjOut<NamedValue> NamedValue_out;

enum NVListFlags {
    IN_COPY_VALUE = 0x0001,
    DEPENDENT_LIST = 0x0002
};


class NVList : public ServerlessObject {
    vector<NamedValue_var> _vec;
public:
    typedef CORBA::Bounds Bounds;
    typedef CORBA::Bounds_catch Bounds_catch;

    ULong count () const
    { (this)->_check (); return _vec.size(); }

    NamedValue_ptr add (Flags);
    NamedValue_ptr add_item (const char *, Flags);
    NamedValue_ptr add_value (const char *, const Any &, Flags);
    NamedValue_ptr add_item_consume (char *, Flags);
    NamedValue_ptr add_value_consume (char *, Any *, Flags);
    NamedValue_ptr item (ULong idx);
    void remove (ULong);


    NVList (ULong count = 0);
    ~NVList ();

    CORBA::Boolean copy (NVList_ptr, Flags flags);


    static NVList_ptr _duplicate (NVList_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static NVList_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<NVList> NVList_var;
typedef ObjOut<NVList> NVList_out;



class ExceptionList : public ServerlessObject {
    vector<TypeCode_var> _vec;

public:
    typedef CORBA::Bounds Bounds;
    typedef CORBA::Bounds_catch Bounds_catch;

    ULong count () const
    { (this)->_check (); return _vec.size(); }

    void add (TypeCode_ptr tc);
    void add_consume (TypeCode_ptr tc);
    TypeCode_ptr item (ULong idx);
    void remove (ULong idx);


    ExceptionList ();
    ~ExceptionList ();


    static ExceptionList_ptr _duplicate (ExceptionList_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static ExceptionList_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<ExceptionList> ExceptionList_var;
typedef ObjOut<ExceptionList> ExceptionList_out;



class ContextList : public ServerlessObject {
    vector<string> _vec;

public:
    typedef CORBA::Bounds Bounds;
    typedef CORBA::Bounds_catch Bounds_catch;

    ULong count () const
    { (this)->_check (); return _vec.size(); }

    void add (const char *ctxt);
    void add_consume (char *ctxt);
    const char *item (ULong idx);
    void remove (ULong idx);


    ContextList ();
    ~ContextList ();


    static ContextList_ptr _duplicate (ContextList_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static ContextList_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<ContextList> ContextList_var;


enum ArgModeFlags {
    ARG_IN = 0x0001,
    ARG_OUT = 0x0002,
    ARG_INOUT = 0x0004
};

enum RequestFlags {
    OUT_LIST_MEMORY = 0x0001,
    INV_NO_RESPONSE = 0x0002,
    INV_TERM_ON_ERR = 0x0004,
    RESP_NO_WAIT = 0x0008
};

struct RequestCallback {
    enum Event { RequestDone };
    virtual void callback (Request_ptr, Event) = 0;
    virtual ~RequestCallback ();
};


class Request : public ServerlessObject, public ORBCallback {
    typedef ULong MsgId;

    Object_var _object;
    Context_ptr _context;
    String_var _opname;
    NVList_ptr _args;
    NamedValue_ptr _res;
    Flags _flags;
    ExceptionList_ptr _elist;
    ContextList_ptr _clist;
    Environment_ptr _environm;
    MsgId _msgid;
    Boolean _invoke_pending;
    ORBRequest *_orbreq;
    RequestCallback *_cb;
    ServerlessObject_ptr _iceptreq;

    Request (const Request &r)
        : CORBA::ServerlessObject (r),
          CORBA::ORBCallback ()
    { ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/dii.h", 261, __PRETTY_FUNCTION__), 0))); }

    Request &operator= (const Request &) { ((void) ((0) ? 0 : (__assert_fail ("0", "../include/mico/dii.h", 263, __PRETTY_FUNCTION__), 0))); return *_nil(); }

    void decode_user_exception ();

    virtual void callback (ORB_ptr, ULong, ORBCallback::Event);
public:
    Object_ptr target () const
    { return _object.in(); }

    const char *operation () const
    { return _opname; }

    NVList_ptr arguments ()
    { (this)->_check (); return _args; }

    NamedValue_ptr result ()
    { return _res; }

    Environment_ptr env ()
    { return _environm; }

    ExceptionList_ptr exceptions ()
    { return _elist; }

    ContextList_ptr contexts ()
    { return _clist; }

    void ctx (Context_ptr);
    Context_ptr ctx () const
    { return _context; }

    void invoke ();
    void send_oneway ();
    void send_deferred (RequestCallback *cb = 0);
    void get_response (Boolean block = 1);
    Boolean poll_response ();

    Any &add_in_arg ();
    Any &add_in_arg (const char *name);
    Any &add_inout_arg ();
    Any &add_inout_arg (const char *name);
    Any &add_out_arg ();
    Any &add_out_arg (const char *name);
    void set_return_type (TypeCode_ptr);
    Any &return_value ();


    Request (Object_ptr, Context_ptr, const char *op,
             NVList_ptr args, NamedValue_ptr result,
             Flags f);
    Request (Object_ptr, Context_ptr, const char *op,
             NVList_ptr args, NamedValue_ptr result,
             ExceptionList_ptr, ContextList_ptr,
             Flags f);
    Request (Object_ptr, const char *op);
    Request ();
    ~Request ();


    static Request_ptr _duplicate (Request_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static Request_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<Request> Request_var;


enum ContextFlags {
    CTX_DELETE_DESCENDENTS = 0x0001,
    CTX_RESTRICT_SCOPE = 0x0002
};

typedef ObjVar<Context> Context_var;
typedef ObjOut<Context> Context_out;


class Context : public ServerlessObject {
    Context_ptr _myparent;
    vector<Context_var> _childs;
    NVList_var _properties;
    string _name;

    Boolean match (const char *value, const char *pattern);
public:
    const char *context_name () const;
    Context_ptr parent () const;

    void create_child (const char *, Context_out);

    void set_one_value (const char *, const Any &);
    void set_values (NVList_ptr);
    void delete_values (const char *);
    void get_values (const char *, Flags, const char *, NVList_out);
    void get_values (const char *, Flags, ContextList_ptr, NVList_out);


    Context (DataDecoder &);
    Context (const char *name, Context_ptr parent = 0);
    ~Context ();

    void encode (DataEncoder &, ContextList_ptr = 0) const;
    Boolean decode (DataDecoder &);


    static Context_ptr _duplicate (Context_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static Context_ptr _nil ()
    {
        return 0;
    }
};



class Principal : public ServerlessObject {
    vector<Octet> _rep;
    static vector<Octet> _peer_info;
    CORBA::Transport *_transp;
public:

    Principal (DataDecoder &, CORBA::Transport * = 0);
    Principal (CORBA::Transport * = 0);
    virtual ~Principal ();

    CORBA::Boolean operator== (const Principal &) const;

    void encode (DataEncoder &) const;
    Boolean decode (DataDecoder &);

    typedef StringSequenceTmpl<String_var> PropertyNameList;
    typedef PropertyNameList *PropertyNameList_ptr;
    typedef TVarVar<PropertyNameList> PropertyNameList_var;
    typedef TVarOut<PropertyNameList> PropertyNameList_out;

    virtual PropertyNameList_ptr list_properties ();
    virtual Any* get_property (const char *prop_name);

    static void set_peer_info (const OctetSeq &);


    static Principal_ptr _duplicate (Principal_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static Principal_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<Principal> Principal_var;

}
# 198 "../include/CORBA.h" 2
# 1 "../include/mico/dsi.h" 1
# 27 "../include/mico/dsi.h"
namespace CORBA {

class ObjectAdapter;
class ORBRequest;

class ServerRequestBase : public CORBA::ServerlessObject {
protected:
    CORBA::Boolean _canceled;
public:
    ServerRequestBase ()
        : _canceled (0)
    {}
    virtual ~ServerRequestBase ();

    virtual CORBA::Environment_ptr environment () = 0;
    void cancel ()
    { _canceled = 1; }

    static ServerRequestBase_ptr _duplicate (ServerRequestBase_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static ServerRequestBase_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<ServerRequestBase> ServerRequestBase_var;
# 69 "../include/mico/dsi.h"
class ServerRequest : public ServerRequestBase {
    typedef CORBA::ULong MsgId;
    CORBA::ObjectAdapter *_oa;
    MsgId _msgid;
    Object_ptr _obj;
    ORBRequest *_req;
    NVList_ptr _dir_params;
    Context_ptr _context;
    Any_var _res;
    Environment _env;
    ServerlessObject_ptr _iceptreq;
    CORBA::Boolean _aborted;
public:

    ServerRequest (ORBRequest *req, Object_ptr obj, MsgId msgid,
                   CORBA::ObjectAdapter *oa, CORBA::Principal_ptr);
    ~ServerRequest ();

    ORBRequest *request ();
    void set_out_args ();
    NVList_ptr arguments ();
    Any *result ();
    Exception *exception ();
    Environment_ptr environment ();



    const char * operation ();
    void arguments (NVList_ptr &);
    void set_result (const Any &);
    void set_exception (const Any &);


    const char *op_name ();
    OperationDef_ptr op_def ();
    Context_ptr ctx ();
    CORBA::Boolean params (NVList_ptr params);
    void result (Any *val);
    void exception (Any *val);
    void exception (Exception *ex);

    static ServerRequest_ptr _duplicate (ServerRequest_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static ServerRequest_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<ServerRequest> ServerRequest_var;

}
# 199 "../include/CORBA.h" 2
# 1 "../include/mico/static.h" 1
# 27 "../include/mico/static.h"
namespace CORBA {

typedef void *StaticValueType;
typedef const void *ConstStaticValueType;

class StaticTypeInfo {
protected:
    virtual ~StaticTypeInfo ();
public:
    typedef CORBA::StaticValueType StaticValueType;

    virtual StaticValueType create () const = 0;
    virtual StaticValueType copy (const StaticValueType) const;
    virtual void assign (StaticValueType dst, const StaticValueType src) const = 0;
    virtual void free (StaticValueType) const = 0;
    virtual CORBA::Boolean demarshal (CORBA::DataDecoder &,
                                      StaticValueType) const = 0;
    virtual void marshal (CORBA::DataEncoder &, StaticValueType) const = 0;
    virtual CORBA::TypeCode_ptr typecode ();
};

extern StaticTypeInfo *_stc_void;
extern StaticTypeInfo *_stc_short;
extern StaticTypeInfo *_stc_long;
extern StaticTypeInfo *_stc_longlong;
extern StaticTypeInfo *_stc_ushort;
extern StaticTypeInfo *_stc_ulong;
extern StaticTypeInfo *_stc_ulonglong;
extern StaticTypeInfo *_stc_float;
extern StaticTypeInfo *_stc_double;
extern StaticTypeInfo *_stc_longdouble;
extern StaticTypeInfo *_stc_char;
extern StaticTypeInfo *_stc_wchar;
extern StaticTypeInfo *_stc_octet;
extern StaticTypeInfo *_stc_boolean;
extern StaticTypeInfo *_stc_any;
extern StaticTypeInfo *_stc_TypeCode;
extern StaticTypeInfo *_stc_Principal;
extern StaticTypeInfo *_stc_Context;
extern StaticTypeInfo *_stc_Object;
extern StaticTypeInfo *_stc_ValueBase;
extern StaticTypeInfo *_stc_AbstractBase;
extern StaticTypeInfo *_stc_string;
extern StaticTypeInfo *_stc_wstring;

extern StaticTypeInfo *_stcseq_short;
extern StaticTypeInfo *_stcseq_long;
extern StaticTypeInfo *_stcseq_longlong;
extern StaticTypeInfo *_stcseq_ushort;
extern StaticTypeInfo *_stcseq_ulong;
extern StaticTypeInfo *_stcseq_ulonglong;
extern StaticTypeInfo *_stcseq_float;
extern StaticTypeInfo *_stcseq_double;
extern StaticTypeInfo *_stcseq_longdouble;
extern StaticTypeInfo *_stcseq_char;
extern StaticTypeInfo *_stcseq_wchar;
extern StaticTypeInfo *_stcseq_octet;
extern StaticTypeInfo *_stcseq_boolean;
extern StaticTypeInfo *_stcseq_any;
extern StaticTypeInfo *_stcseq_string;
extern StaticTypeInfo *_stcseq_wstring;
extern StaticTypeInfo *_stcseq_Object;
extern StaticTypeInfo *_stcseq_ValueBase;
extern StaticTypeInfo *_stcseq_AbstractBase;


class StaticAny {
    StaticTypeInfo *_info;
    StaticValueType _val;
    CORBA::Boolean _dofree;
    CORBA::Flags _flags;
public:
    StaticAny (StaticTypeInfo *info = _stc_void, ConstStaticValueType val = 0,
               CORBA::Boolean dofree = 0)
        : _info (info), _val ((StaticValueType)val), _dofree (dofree)
    {}

    StaticAny (const StaticAny &a);
    StaticAny &operator= (const StaticAny &);
    ~StaticAny ();

    StaticTypeInfo *type ()
    { return _info; }

    CORBA::TypeCode_ptr typecode ()
    { return _info->typecode(); }

    StaticValueType value ()
    { return _val; }

    StaticValueType _retn ();

    void value (StaticTypeInfo *info ,
                ConstStaticValueType val = 0,
                CORBA::Boolean dofree = 0);

    void flags (CORBA::Flags f)
    { _flags = f; }

    CORBA::Flags flags () const
    { return _flags; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &);
    CORBA::Boolean marshal (CORBA::DataEncoder &);
};


class StaticRequest;
typedef StaticRequest *StaticRequest_ptr;

class StaticRequest : public CORBA::ORBRequest {
    CORBA::String_var _opname;
    StaticAnyList _args;
    StaticAny *_res;
    CORBA::Context_ptr _ctx;
    CORBA::Environment_ptr _env;
    CORBA::ContextList_ptr _ctx_list;
    CORBA::Object_var _obj;
    CORBA::ServerlessObject_ptr _iceptreq;
    CORBA::ULong _msgid;

    CORBA::Boolean copy (StaticAnyList *t, StaticAnyList *f, CORBA::Flags);
    CORBA::Environment_ptr env ();
public:
    StaticRequest (CORBA::Object_ptr, const char *opname);
    ~StaticRequest ();


    CORBA::Environment_ptr environment ();


    const char *op_name();

    CORBA::Boolean get_in_args (NVList_ptr iparams, Context_ptr &ctx);
    CORBA::Boolean get_in_args (StaticAnyList *iparams,
                                CORBA::Context_ptr &ctx);
    CORBA::Boolean get_in_args (DataEncoder *);

    CORBA::Boolean get_out_args (Any *res, NVList_ptr oparams,
                                 Exception *&ex);
    CORBA::Boolean get_out_args (CORBA::StaticAny *res, StaticAnyList *oparams,
                                 CORBA::Exception *&ex);
    CORBA::Boolean get_out_args (DataEncoder *, Boolean &is_except);

    CORBA::Boolean set_out_args (Any *res, NVList_ptr oparams);
    CORBA::Boolean set_out_args (CORBA::StaticAny *res,
                                 StaticAnyList *oparams);
    void set_out_args (Exception *ex);
    CORBA::Boolean set_out_args (CORBA::DataDecoder *,
                                 CORBA::Boolean is_except);

    CORBA::Boolean copy_out_args (ORBRequest *);
    CORBA::Boolean copy_in_args (ORBRequest *);

    const char *type ();


    void add_in_arg (StaticAny *);
    void add_out_arg (StaticAny *);
    void add_inout_arg (StaticAny *);
    void set_context (CORBA::Context_ptr);
    void set_context_list (CORBA::ContextList_ptr);
    void set_result (StaticAny *a)
    {
        _res = a;
    }

    CORBA::Exception *exception ();
    void exception (CORBA::Exception *);

    void invoke ();
    void oneway ();

    void send_deferred ();
    void get_response ();

    static StaticRequest_ptr _duplicate (StaticRequest_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static StaticRequest_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<StaticRequest> StaticRequest_var;


class StaticServerRequest : public CORBA::ServerRequestBase {
    typedef vector<StaticAny *> StaticAnyList;
    typedef CORBA::ULong MsgId;

    CORBA::ObjectAdapter *_oa;
    CORBA::Object_ptr _obj;
    CORBA::Context_ptr _ctx;
    CORBA::Environment _env;
    ORBRequest *_req;
    StaticAnyList _args;
    StaticAny *_res;
    MsgId _msgid;
    CORBA::ServerlessObject_ptr _iceptreq;
    CORBA::Boolean _aborted;
public:
    StaticServerRequest (ORBRequest *req, Object_ptr obj, MsgId msgid,
                         CORBA::ObjectAdapter *oa, CORBA::Principal_ptr);
    ~StaticServerRequest ();

    const char *op_name()
    {
        return _req->op_name();
    }
    CORBA::Context_ptr ctx ()
    {
        return _ctx;
    }

    void add_in_arg (StaticAny *);
    void add_out_arg (StaticAny *);
    void add_inout_arg (StaticAny *);

    void set_result (StaticAny *a)
    {
        _res = a;
    }
    void set_exception (CORBA::Exception *e)
    {
        _env.exception (e);
    }

    CORBA::Boolean read_args ();
    void write_results ();

    CORBA::Environment_ptr environment ()
    {
        return &_env;
    }

    static StaticServerRequest_ptr _duplicate (StaticServerRequest_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static StaticServerRequest_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<StaticServerRequest> StaticServerRequest_var;


}
# 200 "../include/CORBA.h" 2
# 1 "../include/mico/tcconst.h" 1
# 27 "../include/mico/tcconst.h"
namespace CORBA {

class TypeCodeConst {
    TypeCode_ptr _tc;
    const char *_str;
public:
    TypeCodeConst ();
    TypeCodeConst (const char *s);
    TypeCodeConst &operator= (const char *s);
    TypeCode_ptr operator->();
    operator TypeCode_ptr();
};

}
# 201 "../include/CORBA.h" 2

# 1 "../include/mico/policy.h" 1
# 12 "../include/mico/policy.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/policy.h" 2



namespace CORBA {






typedef PolicyType& PolicyType_out;
class Policy;

typedef Policy_ptr PolicyRef;





class Policy :
  virtual public CORBA::Object
{
  public:
    virtual ~Policy();


    typedef Policy_ptr _ptr_type;
    typedef Policy_var _var_type;


    static Policy_ptr _narrow( CORBA::Object_ptr obj );
    static Policy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Policy_ptr _duplicate( Policy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Policy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual PolicyType policy_type() = 0;

    virtual Policy_ptr copy() = 0;
    virtual void destroy() = 0;

  protected:
    Policy() {};
  private:
    Policy( const Policy& );
    void operator=( const Policy& );
};






typedef TSeqVar<IfaceSequenceTmpl<Policy_var,Policy_ptr> > PolicyList_var;
typedef TSeqOut<IfaceSequenceTmpl<Policy_var,Policy_ptr> > PolicyList_out;






typedef SetOverrideType& SetOverrideType_out;

class DomainManager;

typedef DomainManager_ptr DomainManagerRef;





class DomainManager :
  virtual public CORBA::Object
{
  public:
    virtual ~DomainManager();


    typedef DomainManager_ptr _ptr_type;
    typedef DomainManager_var _var_type;


    static DomainManager_ptr _narrow( CORBA::Object_ptr obj );
    static DomainManager_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DomainManager_ptr _duplicate( DomainManager_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DomainManager_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Policy_ptr get_domain_policy( PolicyType policy_type ) = 0;
    virtual void set_domain_policy( Policy_ptr policy ) = 0;
    virtual DomainManager_ptr copy() = 0;

  protected:
    DomainManager() {};
  private:
    DomainManager( const DomainManager& );
    void operator=( const DomainManager& );
};


extern const CORBA::ULong SecConstruction;
class ConstructionPolicy;
typedef ConstructionPolicy *ConstructionPolicy_ptr;
typedef ConstructionPolicy_ptr ConstructionPolicyRef;
typedef ObjVar<ConstructionPolicy> ConstructionPolicy_var;
typedef ObjOut<ConstructionPolicy> ConstructionPolicy_out;



class ConstructionPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~ConstructionPolicy();


    typedef ConstructionPolicy_ptr _ptr_type;
    typedef ConstructionPolicy_var _var_type;


    static ConstructionPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static ConstructionPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ConstructionPolicy_ptr _duplicate( ConstructionPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ConstructionPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void make_domain_manager( InterfaceDef_ptr object_type, CORBA::Boolean constr_policy ) = 0;
    virtual CORBA::Boolean constr_policy( CORBA::Object_ptr object ) = 0;

  protected:
    ConstructionPolicy() {};
  private:
    ConstructionPolicy( const ConstructionPolicy& );
    void operator=( const ConstructionPolicy& );
};






typedef TSeqVar<IfaceSequenceTmpl<DomainManager_var,DomainManager_ptr> > DomainManagerList_var;
typedef TSeqOut<IfaceSequenceTmpl<DomainManager_var,DomainManager_ptr> > DomainManagerList_out;

typedef CORBA::Short PolicyErrorCode;
typedef PolicyErrorCode& PolicyErrorCode_out;
extern const CORBA::Short BAD_POLICY;
extern const CORBA::Short UNSUPPORTED_POLICY;
extern const CORBA::Short BAD_POLICY_TYPE;
extern const CORBA::Short BAD_POLICY_VALUE;
extern const CORBA::Short UNSUPPORTED_POLICY_VALUE;
struct PolicyError : public UserException {
# 201 "../include/mico/policy.h"
  PolicyError();

  PolicyError( PolicyErrorCode _m0 );


  PolicyError *operator->() { return this; }
  PolicyError& operator*() { return *this; }
  operator PolicyError*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static PolicyError *_downcast( CORBA::Exception *ex );
  static const PolicyError *_downcast( const CORBA::Exception *ex );
  PolicyErrorCode reason;
};


typedef PolicyError PolicyError_catch;
# 233 "../include/mico/policy.h"
}
# 248 "../include/mico/policy.h"
# 1 "../include/mico/template_impl.h" 1
# 249 "../include/mico/policy.h" 2
# 203 "../include/CORBA.h" 2
# 1 "../include/mico/current.h" 1
# 12 "../include/mico/current.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/current.h" 2



namespace CORBA {





class Current;
typedef Current *Current_ptr;
typedef Current_ptr CurrentRef;
typedef ObjVar<Current> Current_var;
typedef ObjOut<Current> Current_out;



class Current :
  virtual public CORBA::Object
{
  public:
    virtual ~Current();


    typedef Current_ptr _ptr_type;
    typedef Current_var _var_type;


    static Current_ptr _narrow( CORBA::Object_ptr obj );
    static Current_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Current_ptr _duplicate( Current_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Current_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    Current() {};
  private:
    Current( const Current& );
    void operator=( const Current& );
};


class PrincipalCurrent;
typedef PrincipalCurrent *PrincipalCurrent_ptr;
typedef PrincipalCurrent_ptr PrincipalCurrentRef;
typedef ObjVar<PrincipalCurrent> PrincipalCurrent_var;
typedef ObjOut<PrincipalCurrent> PrincipalCurrent_out;



class PrincipalCurrent :
  virtual public ::CORBA::Current
{
  public:
    typedef ::CORBA::Current _VCHACK__CORBA__Current;
    virtual ~PrincipalCurrent();


    typedef PrincipalCurrent_ptr _ptr_type;
    typedef PrincipalCurrent_var _var_type;


    static PrincipalCurrent_ptr _narrow( CORBA::Object_ptr obj );
    static PrincipalCurrent_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PrincipalCurrent_ptr _duplicate( PrincipalCurrent_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PrincipalCurrent_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Principal_ptr get_principal() = 0;

  protected:
    PrincipalCurrent() {};
  private:
    PrincipalCurrent( const PrincipalCurrent& );
    void operator=( const PrincipalCurrent& );
};






}
# 128 "../include/mico/current.h"
# 1 "../include/mico/template_impl.h" 1
# 129 "../include/mico/current.h" 2
# 204 "../include/CORBA.h" 2

# 1 "../include/mico/boa.h" 1
# 27 "../include/mico/boa.h"
namespace CORBA {



class ORBRequest;

class BOA : public ServerlessObject {
public:

    typedef SequenceTmpl<Octet,3> ReferenceData;
    typedef TSeqVar<ReferenceData> ReferenceData_var;

    virtual Object_ptr create (const ReferenceData &,
                               InterfaceDef *,
                               ImplementationDef *,
                               ImplementationBase * = __null,
                               const char *repoid = 0) = 0;

    virtual ~BOA ();
    virtual Boolean restoring () = 0;
    virtual Object_ptr restore (Object_ptr orig,
                                const ReferenceData &,
                                InterfaceDef *,
                                ImplementationDef *,
                                ImplementationBase *) = 0;
    virtual ORB_ptr orb () = 0;
    virtual const char *impl_name () = 0;
    virtual void save_objects () = 0;
    virtual void dispose_objects () = 0;


    virtual void dispose (Object_ptr) = 0;
    virtual ReferenceData *get_id (Object_ptr) = 0;
    virtual void change_implementation (Object_ptr,
                                        ImplementationDef *) = 0;
    virtual Principal_ptr get_principal (Object_ptr, Environment_ptr) = 0;

    virtual void impl_is_ready (ImplementationDef *) = 0;
    virtual void deactivate_impl (ImplementationDef *) = 0;
    virtual void obj_is_ready (Object_ptr, ImplementationDef *) = 0;
    virtual void deactivate_obj (Object_ptr) = 0;

    static BOA_ptr _duplicate (BOA_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static BOA_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<BOA> BOA_var;


class BOAObjectRestorer {
    ServerlessObject *_boa_interceptor;
public:
    BOAObjectRestorer ();
    virtual ~BOAObjectRestorer ();

    virtual Boolean restore (Object_ptr);
    virtual Boolean bind (const char *repoid,
                          const SequenceTmpl<Octet,3> &tag);
};

class ImplementationBase : virtual public CORBA::Object {
protected:
    ORB_ptr _morb;
    BOA_ptr _mboa;
public:
    ImplementationBase ();
    virtual ~ImplementationBase ();

    virtual CORBA::Boolean _save_object ();
    ORB_ptr _orb ();
    ORB_ptr _orbnc ();

    virtual void _create_ref (const BOA::ReferenceData &, InterfaceDef *,
                              ImplementationDef *, const char *repoid);
    virtual void _restore_ref (Object_ptr orig, const BOA::ReferenceData &,
                               InterfaceDef *, ImplementationDef *);
    virtual void _dispose_ref ();
    virtual const char *_impl_name (const char *);

    ImplementationDef *_find_impl (const char *repoid, const char *name);
    InterfaceDef *_find_iface (const char *repoid);

    BOA_ptr _boa ();
    Object_ptr _this ();

    virtual ServerRequestBase_ptr make_request (ORBRequest *,
                                                CORBA::Object_ptr,
                                                CORBA::ULong,
                                                CORBA::ObjectAdapter *,
                                                CORBA::Principal_ptr) = 0;

    virtual void doinvoke (ServerRequestBase_ptr request,
                           Environment &env) = 0;
};



class DynamicImplementation : virtual public ImplementationBase {
public:
    DynamicImplementation ();
    virtual ~DynamicImplementation ();


    virtual ServerRequestBase_ptr make_request (ORBRequest *,
                                                CORBA::Object_ptr,
                                                CORBA::ULong,
                                                CORBA::ObjectAdapter *,
                                                CORBA::Principal_ptr);
    virtual void doinvoke (ServerRequestBase_ptr request,
                           Environment &env);
    virtual void invoke (ServerRequest_ptr request,
                         Environment &env) = 0;
};

class StaticImplementation : virtual public CORBA::ImplementationBase {
public:
    StaticImplementation ();
    virtual ~StaticImplementation ();

    virtual ServerRequestBase_ptr make_request (ORBRequest *,
                                                CORBA::Object_ptr,
                                                CORBA::ULong,
                                                CORBA::ObjectAdapter *,
                                                CORBA::Principal_ptr);
    virtual void doinvoke (ServerRequestBase_ptr request,
                           Environment &env);
    virtual void invoke (StaticServerRequest_ptr request,
                         Environment &env) = 0;
};



class InterfaceDispatcher {
public:
    virtual ~InterfaceDispatcher ();
    virtual bool dispatch( CORBA::ServerRequest_ptr _req,
                           CORBA::Environment &_env ) = 0;
};
# 181 "../include/mico/boa.h"
class MethodDispatcher : public virtual CORBA::DynamicImplementation {
protected:
    void register_dispatcher( InterfaceDispatcher *disp );
public:
    virtual ~MethodDispatcher ();
    virtual void invoke( CORBA::ServerRequest_ptr _req,
                         CORBA::Environment &_env );
private:
    typedef vector<InterfaceDispatcher*> VecInterfaceDispatcher;
    VecInterfaceDispatcher _dispatcher;
};


class StaticInterfaceDispatcher {
public:
    virtual ~StaticInterfaceDispatcher ();
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req,
                           CORBA::Environment &_env ) = 0;
};
# 208 "../include/mico/boa.h"
class StaticMethodDispatcher : public virtual CORBA::StaticImplementation {
protected:
    void register_dispatcher( StaticInterfaceDispatcher *disp );
public:
    virtual ~StaticMethodDispatcher ();
    virtual void invoke( CORBA::StaticServerRequest_ptr _req,
                         CORBA::Environment &_env );
private:
    typedef vector<StaticInterfaceDispatcher*> VecInterfaceDispatcher;
    VecInterfaceDispatcher _dispatcher;
};

}





template<class T>
class InterfaceDispatcherWrapper : public CORBA::InterfaceDispatcher {
private:
    T* _interface;
public:
    InterfaceDispatcherWrapper( T* iface )
    {
        _interface = iface;
    }
    virtual bool dispatch( CORBA::ServerRequest_ptr _req,
                           CORBA::Environment &_env )
    {
        return _interface->dispatch( _req, _env );
    }
};

typedef CORBA::MethodDispatcher MethodDispatcher;
typedef CORBA::InterfaceDispatcher InterfaceDispatcher;

template<class T>
class StaticInterfaceDispatcherWrapper :
  public CORBA::StaticInterfaceDispatcher {
private:
    T* _interface;
public:
    StaticInterfaceDispatcherWrapper( T* iface )
    {
        _interface = iface;
    }
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req,
                           CORBA::Environment &_env )
    {
        return _interface->dispatch( _req, _env );
    }
};

typedef CORBA::StaticMethodDispatcher StaticMethodDispatcher;
typedef CORBA::StaticInterfaceDispatcher StaticInterfaceDispatcher;
# 206 "../include/CORBA.h" 2


namespace PortableServer {
  class ServantBase;
}
# 1 "../include/mico/poa.h" 1
# 12 "../include/mico/poa.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/poa.h" 2



namespace PortableServer {





class POA;
typedef POA *POA_ptr;
typedef POA_ptr POARef;
typedef ObjVar<POA> POA_var;
typedef ObjOut<POA> POA_out;

typedef IfaceSequenceTmpl<POA_var,POA_ptr> POAList;



typedef TSeqVar<IfaceSequenceTmpl<POA_var,POA_ptr> > POAList_var;
typedef TSeqOut<IfaceSequenceTmpl<POA_var,POA_ptr> > POAList_out;

extern CORBA::TypeCodeConst _tc_POAList;

typedef PortableServer::ServantBase* Servant;
typedef PortableServer::ServantBase*& Servant_out;

typedef SequenceTmpl<CORBA::Octet,3> ObjectId;



typedef TSeqVar<SequenceTmpl<CORBA::Octet,3> > ObjectId_var;
typedef TSeqOut<SequenceTmpl<CORBA::Octet,3> > ObjectId_out;

extern CORBA::TypeCodeConst _tc_ObjectId;

struct ForwardRequest : public CORBA::UserException {
# 58 "../include/mico/poa.h"
  ForwardRequest();

  ForwardRequest( CORBA::Object_ptr _m0 );


  ForwardRequest *operator->() { return this; }
  ForwardRequest& operator*() { return *this; }
  operator ForwardRequest*() { return this; }


  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static ForwardRequest *_downcast( CORBA::Exception *ex );
  static const ForwardRequest *_downcast( const CORBA::Exception *ex );
  CORBA::Object_var forward_reference;
};


typedef ForwardRequest ForwardRequest_catch;






extern CORBA::TypeCodeConst _tc_ForwardRequest;

extern const CORBA::ULong THREAD_POLICY_ID;
extern const CORBA::ULong LIFESPAN_POLICY_ID;
extern const CORBA::ULong ID_UNIQUENESS_POLICY_ID;
extern const CORBA::ULong ID_ASSIGNMENT_POLICY_ID;
extern const CORBA::ULong IMPLICIT_ACTIVATION_POLICY_ID;
extern const CORBA::ULong SERVANT_RETENTION_POLICY_ID;
extern const CORBA::ULong REQUEST_PROCESSING_POLICY_ID;
enum ThreadPolicyValue {
  ORB_CTRL_MODEL = 0,
  SINGLE_THREAD_MODEL
};

typedef ThreadPolicyValue& ThreadPolicyValue_out;

extern CORBA::TypeCodeConst _tc_ThreadPolicyValue;

class ThreadPolicy;
typedef ThreadPolicy *ThreadPolicy_ptr;
typedef ThreadPolicy_ptr ThreadPolicyRef;
typedef ObjVar<ThreadPolicy> ThreadPolicy_var;
typedef ObjOut<ThreadPolicy> ThreadPolicy_out;



class ThreadPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~ThreadPolicy();


    typedef ThreadPolicy_ptr _ptr_type;
    typedef ThreadPolicy_var _var_type;


    static ThreadPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static ThreadPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ThreadPolicy_ptr _duplicate( ThreadPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ThreadPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ThreadPolicyValue value() = 0;

  protected:
    ThreadPolicy() {};
  private:
    ThreadPolicy( const ThreadPolicy& );
    void operator=( const ThreadPolicy& );
};


enum LifespanPolicyValue {
  TRANSIENT = 0,
  PERSISTENT
};

typedef LifespanPolicyValue& LifespanPolicyValue_out;

extern CORBA::TypeCodeConst _tc_LifespanPolicyValue;

class LifespanPolicy;
typedef LifespanPolicy *LifespanPolicy_ptr;
typedef LifespanPolicy_ptr LifespanPolicyRef;
typedef ObjVar<LifespanPolicy> LifespanPolicy_var;
typedef ObjOut<LifespanPolicy> LifespanPolicy_out;



class LifespanPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~LifespanPolicy();


    typedef LifespanPolicy_ptr _ptr_type;
    typedef LifespanPolicy_var _var_type;


    static LifespanPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static LifespanPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static LifespanPolicy_ptr _duplicate( LifespanPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static LifespanPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual LifespanPolicyValue value() = 0;

  protected:
    LifespanPolicy() {};
  private:
    LifespanPolicy( const LifespanPolicy& );
    void operator=( const LifespanPolicy& );
};


enum IdUniquenessPolicyValue {
  UNIQUE_ID = 0,
  MULTIPLE_ID
};

typedef IdUniquenessPolicyValue& IdUniquenessPolicyValue_out;

extern CORBA::TypeCodeConst _tc_IdUniquenessPolicyValue;

class IdUniquenessPolicy;
typedef IdUniquenessPolicy *IdUniquenessPolicy_ptr;
typedef IdUniquenessPolicy_ptr IdUniquenessPolicyRef;
typedef ObjVar<IdUniquenessPolicy> IdUniquenessPolicy_var;
typedef ObjOut<IdUniquenessPolicy> IdUniquenessPolicy_out;



class IdUniquenessPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~IdUniquenessPolicy();


    typedef IdUniquenessPolicy_ptr _ptr_type;
    typedef IdUniquenessPolicy_var _var_type;


    static IdUniquenessPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static IdUniquenessPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static IdUniquenessPolicy_ptr _duplicate( IdUniquenessPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static IdUniquenessPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual IdUniquenessPolicyValue value() = 0;

  protected:
    IdUniquenessPolicy() {};
  private:
    IdUniquenessPolicy( const IdUniquenessPolicy& );
    void operator=( const IdUniquenessPolicy& );
};


enum IdAssignmentPolicyValue {
  USER_ID = 0,
  SYSTEM_ID
};

typedef IdAssignmentPolicyValue& IdAssignmentPolicyValue_out;

extern CORBA::TypeCodeConst _tc_IdAssignmentPolicyValue;

class IdAssignmentPolicy;
typedef IdAssignmentPolicy *IdAssignmentPolicy_ptr;
typedef IdAssignmentPolicy_ptr IdAssignmentPolicyRef;
typedef ObjVar<IdAssignmentPolicy> IdAssignmentPolicy_var;
typedef ObjOut<IdAssignmentPolicy> IdAssignmentPolicy_out;



class IdAssignmentPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~IdAssignmentPolicy();


    typedef IdAssignmentPolicy_ptr _ptr_type;
    typedef IdAssignmentPolicy_var _var_type;


    static IdAssignmentPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static IdAssignmentPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static IdAssignmentPolicy_ptr _duplicate( IdAssignmentPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static IdAssignmentPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual IdAssignmentPolicyValue value() = 0;

  protected:
    IdAssignmentPolicy() {};
  private:
    IdAssignmentPolicy( const IdAssignmentPolicy& );
    void operator=( const IdAssignmentPolicy& );
};


enum ImplicitActivationPolicyValue {
  IMPLICIT_ACTIVATION = 0,
  NO_IMPLICIT_ACTIVATION
};

typedef ImplicitActivationPolicyValue& ImplicitActivationPolicyValue_out;

extern CORBA::TypeCodeConst _tc_ImplicitActivationPolicyValue;

class ImplicitActivationPolicy;
typedef ImplicitActivationPolicy *ImplicitActivationPolicy_ptr;
typedef ImplicitActivationPolicy_ptr ImplicitActivationPolicyRef;
typedef ObjVar<ImplicitActivationPolicy> ImplicitActivationPolicy_var;
typedef ObjOut<ImplicitActivationPolicy> ImplicitActivationPolicy_out;



class ImplicitActivationPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~ImplicitActivationPolicy();


    typedef ImplicitActivationPolicy_ptr _ptr_type;
    typedef ImplicitActivationPolicy_var _var_type;


    static ImplicitActivationPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static ImplicitActivationPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ImplicitActivationPolicy_ptr _duplicate( ImplicitActivationPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ImplicitActivationPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ImplicitActivationPolicyValue value() = 0;

  protected:
    ImplicitActivationPolicy() {};
  private:
    ImplicitActivationPolicy( const ImplicitActivationPolicy& );
    void operator=( const ImplicitActivationPolicy& );
};


enum ServantRetentionPolicyValue {
  RETAIN = 0,
  NON_RETAIN
};

typedef ServantRetentionPolicyValue& ServantRetentionPolicyValue_out;

extern CORBA::TypeCodeConst _tc_ServantRetentionPolicyValue;

class ServantRetentionPolicy;
typedef ServantRetentionPolicy *ServantRetentionPolicy_ptr;
typedef ServantRetentionPolicy_ptr ServantRetentionPolicyRef;
typedef ObjVar<ServantRetentionPolicy> ServantRetentionPolicy_var;
typedef ObjOut<ServantRetentionPolicy> ServantRetentionPolicy_out;



class ServantRetentionPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~ServantRetentionPolicy();


    typedef ServantRetentionPolicy_ptr _ptr_type;
    typedef ServantRetentionPolicy_var _var_type;


    static ServantRetentionPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static ServantRetentionPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ServantRetentionPolicy_ptr _duplicate( ServantRetentionPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ServantRetentionPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ServantRetentionPolicyValue value() = 0;

  protected:
    ServantRetentionPolicy() {};
  private:
    ServantRetentionPolicy( const ServantRetentionPolicy& );
    void operator=( const ServantRetentionPolicy& );
};


enum RequestProcessingPolicyValue {
  USE_ACTIVE_OBJECT_MAP_ONLY = 0,
  USE_DEFAULT_SERVANT,
  USE_SERVANT_MANAGER
};

typedef RequestProcessingPolicyValue& RequestProcessingPolicyValue_out;

extern CORBA::TypeCodeConst _tc_RequestProcessingPolicyValue;

class RequestProcessingPolicy;
typedef RequestProcessingPolicy *RequestProcessingPolicy_ptr;
typedef RequestProcessingPolicy_ptr RequestProcessingPolicyRef;
typedef ObjVar<RequestProcessingPolicy> RequestProcessingPolicy_var;
typedef ObjOut<RequestProcessingPolicy> RequestProcessingPolicy_out;



class RequestProcessingPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~RequestProcessingPolicy();


    typedef RequestProcessingPolicy_ptr _ptr_type;
    typedef RequestProcessingPolicy_var _var_type;


    static RequestProcessingPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static RequestProcessingPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static RequestProcessingPolicy_ptr _duplicate( RequestProcessingPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static RequestProcessingPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual RequestProcessingPolicyValue value() = 0;

  protected:
    RequestProcessingPolicy() {};
  private:
    RequestProcessingPolicy( const RequestProcessingPolicy& );
    void operator=( const RequestProcessingPolicy& );
};


class POAManager;
typedef POAManager *POAManager_ptr;
typedef POAManager_ptr POAManagerRef;
typedef ObjVar<POAManager> POAManager_var;
typedef ObjOut<POAManager> POAManager_out;



class POAManager :
  virtual public CORBA::Object
{
  public:
    virtual ~POAManager();


    typedef POAManager_ptr _ptr_type;
    typedef POAManager_var _var_type;


    static POAManager_ptr _narrow( CORBA::Object_ptr obj );
    static POAManager_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static POAManager_ptr _duplicate( POAManager_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static POAManager_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct AdapterInactive : public CORBA::UserException {
# 518 "../include/mico/poa.h"
      AdapterInactive *operator->() { return this; }
      AdapterInactive& operator*() { return *this; }
      operator AdapterInactive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static AdapterInactive *_downcast( CORBA::Exception *ex );
      static const AdapterInactive *_downcast( const CORBA::Exception *ex );
    };


    typedef AdapterInactive AdapterInactive_catch;






    static CORBA::TypeCodeConst _tc_AdapterInactive;

    enum State {
      HOLDING = 0,
      ACTIVE,
      DISCARDING,
      INACTIVE
    };

    typedef State& State_out;

    static CORBA::TypeCodeConst _tc_State;

    virtual void activate() = 0;
    virtual void hold_requests( CORBA::Boolean wait_for_completion ) = 0;
    virtual void discard_requests( CORBA::Boolean wait_for_completion ) = 0;
    virtual void deactivate( CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion ) = 0;
    virtual State get_state() = 0;
    virtual void add_managed_poa( POA_ptr managed ) = 0;
    virtual void del_managed_poa( POA_ptr managed ) = 0;

  protected:
    POAManager() {};
  private:
    POAManager( const POAManager& );
    void operator=( const POAManager& );
};


class AdapterActivator;
typedef AdapterActivator *AdapterActivator_ptr;
typedef AdapterActivator_ptr AdapterActivatorRef;
typedef ObjVar<AdapterActivator> AdapterActivator_var;
typedef ObjOut<AdapterActivator> AdapterActivator_out;



class AdapterActivator :
  virtual public CORBA::Object
{
  public:
    virtual ~AdapterActivator();


    typedef AdapterActivator_ptr _ptr_type;
    typedef AdapterActivator_var _var_type;


    static AdapterActivator_ptr _narrow( CORBA::Object_ptr obj );
    static AdapterActivator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static AdapterActivator_ptr _duplicate( AdapterActivator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static AdapterActivator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean unknown_adapter( POA_ptr parent, const char* name ) = 0;

  protected:
    AdapterActivator() {};
  private:
    AdapterActivator( const AdapterActivator& );
    void operator=( const AdapterActivator& );
};


class ServantManager;
typedef ServantManager *ServantManager_ptr;
typedef ServantManager_ptr ServantManagerRef;
typedef ObjVar<ServantManager> ServantManager_var;
typedef ObjOut<ServantManager> ServantManager_out;



class ServantManager :
  virtual public CORBA::Object
{
  public:
    virtual ~ServantManager();


    typedef ServantManager_ptr _ptr_type;
    typedef ServantManager_var _var_type;


    static ServantManager_ptr _narrow( CORBA::Object_ptr obj );
    static ServantManager_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ServantManager_ptr _duplicate( ServantManager_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ServantManager_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ServantManager() {};
  private:
    ServantManager( const ServantManager& );
    void operator=( const ServantManager& );
};


class ServantActivator;
typedef ServantActivator *ServantActivator_ptr;
typedef ServantActivator_ptr ServantActivatorRef;
typedef ObjVar<ServantActivator> ServantActivator_var;
typedef ObjOut<ServantActivator> ServantActivator_out;



class ServantActivator :
  virtual public ::PortableServer::ServantManager
{
  public:
    typedef ::PortableServer::ServantManager _VCHACK__PortableServer__ServantManager;
    virtual ~ServantActivator();


    typedef ServantActivator_ptr _ptr_type;
    typedef ServantActivator_var _var_type;


    static ServantActivator_ptr _narrow( CORBA::Object_ptr obj );
    static ServantActivator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ServantActivator_ptr _duplicate( ServantActivator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ServantActivator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Servant incarnate( const ObjectId& oid, POA_ptr adapter ) = 0;
    virtual void etherealize( const ObjectId& oid, POA_ptr adapter, Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations ) = 0;

  protected:
    ServantActivator() {};
  private:
    ServantActivator( const ServantActivator& );
    void operator=( const ServantActivator& );
};


class ServantLocator;
typedef ServantLocator *ServantLocator_ptr;
typedef ServantLocator_ptr ServantLocatorRef;
typedef ObjVar<ServantLocator> ServantLocator_var;
typedef ObjOut<ServantLocator> ServantLocator_out;



class ServantLocator :
  virtual public ::PortableServer::ServantManager
{
  public:
    typedef ::PortableServer::ServantManager _VCHACK__PortableServer__ServantManager;
    virtual ~ServantLocator();


    typedef ServantLocator_ptr _ptr_type;
    typedef ServantLocator_var _var_type;


    static ServantLocator_ptr _narrow( CORBA::Object_ptr obj );
    static ServantLocator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ServantLocator_ptr _duplicate( ServantLocator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ServantLocator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    typedef void* Cookie;
    typedef void*& Cookie_out;

    virtual Servant preinvoke( const ObjectId& oid, POA_ptr adapter, const char* operation, Cookie_out the_cookie ) = 0;
    virtual void postinvoke( const ObjectId& oid, POA_ptr adapter, const char* operation, Cookie the_cookie, Servant the_servant ) = 0;

  protected:
    ServantLocator() {};
  private:
    ServantLocator( const ServantLocator& );
    void operator=( const ServantLocator& );
};




class POA :
  virtual public CORBA::Object
{
  public:
    virtual ~POA();


    typedef POA_ptr _ptr_type;
    typedef POA_var _var_type;


    static POA_ptr _narrow( CORBA::Object_ptr obj );
    static POA_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static POA_ptr _duplicate( POA_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static POA_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct AdapterAlreadyExists : public CORBA::UserException {
# 788 "../include/mico/poa.h"
      AdapterAlreadyExists *operator->() { return this; }
      AdapterAlreadyExists& operator*() { return *this; }
      operator AdapterAlreadyExists*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static AdapterAlreadyExists *_downcast( CORBA::Exception *ex );
      static const AdapterAlreadyExists *_downcast( const CORBA::Exception *ex );
    };


    typedef AdapterAlreadyExists AdapterAlreadyExists_catch;






    static CORBA::TypeCodeConst _tc_AdapterAlreadyExists;

    struct AdapterInactive : public CORBA::UserException {
# 822 "../include/mico/poa.h"
      AdapterInactive *operator->() { return this; }
      AdapterInactive& operator*() { return *this; }
      operator AdapterInactive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static AdapterInactive *_downcast( CORBA::Exception *ex );
      static const AdapterInactive *_downcast( const CORBA::Exception *ex );
    };


    typedef AdapterInactive AdapterInactive_catch;






    static CORBA::TypeCodeConst _tc_AdapterInactive;

    struct AdapterNonExistent : public CORBA::UserException {
# 856 "../include/mico/poa.h"
      AdapterNonExistent *operator->() { return this; }
      AdapterNonExistent& operator*() { return *this; }
      operator AdapterNonExistent*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static AdapterNonExistent *_downcast( CORBA::Exception *ex );
      static const AdapterNonExistent *_downcast( const CORBA::Exception *ex );
    };


    typedef AdapterNonExistent AdapterNonExistent_catch;






    static CORBA::TypeCodeConst _tc_AdapterNonExistent;

    struct InvalidPolicy : public CORBA::UserException {
# 889 "../include/mico/poa.h"
      InvalidPolicy();

      InvalidPolicy( CORBA::UShort _m0 );


      InvalidPolicy *operator->() { return this; }
      InvalidPolicy& operator*() { return *this; }
      operator InvalidPolicy*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InvalidPolicy *_downcast( CORBA::Exception *ex );
      static const InvalidPolicy *_downcast( const CORBA::Exception *ex );
      CORBA::UShort index;
    };


    typedef InvalidPolicy InvalidPolicy_catch;






    static CORBA::TypeCodeConst _tc_InvalidPolicy;

    struct NoServant : public CORBA::UserException {
# 929 "../include/mico/poa.h"
      NoServant *operator->() { return this; }
      NoServant& operator*() { return *this; }
      operator NoServant*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static NoServant *_downcast( CORBA::Exception *ex );
      static const NoServant *_downcast( const CORBA::Exception *ex );
    };


    typedef NoServant NoServant_catch;






    static CORBA::TypeCodeConst _tc_NoServant;

    struct ObjectAlreadyActive : public CORBA::UserException {
# 963 "../include/mico/poa.h"
      ObjectAlreadyActive *operator->() { return this; }
      ObjectAlreadyActive& operator*() { return *this; }
      operator ObjectAlreadyActive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ObjectAlreadyActive *_downcast( CORBA::Exception *ex );
      static const ObjectAlreadyActive *_downcast( const CORBA::Exception *ex );
    };


    typedef ObjectAlreadyActive ObjectAlreadyActive_catch;






    static CORBA::TypeCodeConst _tc_ObjectAlreadyActive;

    struct ObjectNotActive : public CORBA::UserException {
# 997 "../include/mico/poa.h"
      ObjectNotActive *operator->() { return this; }
      ObjectNotActive& operator*() { return *this; }
      operator ObjectNotActive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ObjectNotActive *_downcast( CORBA::Exception *ex );
      static const ObjectNotActive *_downcast( const CORBA::Exception *ex );
    };


    typedef ObjectNotActive ObjectNotActive_catch;






    static CORBA::TypeCodeConst _tc_ObjectNotActive;

    struct ServantAlreadyActive : public CORBA::UserException {
# 1031 "../include/mico/poa.h"
      ServantAlreadyActive *operator->() { return this; }
      ServantAlreadyActive& operator*() { return *this; }
      operator ServantAlreadyActive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ServantAlreadyActive *_downcast( CORBA::Exception *ex );
      static const ServantAlreadyActive *_downcast( const CORBA::Exception *ex );
    };


    typedef ServantAlreadyActive ServantAlreadyActive_catch;






    static CORBA::TypeCodeConst _tc_ServantAlreadyActive;

    struct ServantNotActive : public CORBA::UserException {
# 1065 "../include/mico/poa.h"
      ServantNotActive *operator->() { return this; }
      ServantNotActive& operator*() { return *this; }
      operator ServantNotActive*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static ServantNotActive *_downcast( CORBA::Exception *ex );
      static const ServantNotActive *_downcast( const CORBA::Exception *ex );
    };


    typedef ServantNotActive ServantNotActive_catch;






    static CORBA::TypeCodeConst _tc_ServantNotActive;

    struct WrongAdapter : public CORBA::UserException {
# 1099 "../include/mico/poa.h"
      WrongAdapter *operator->() { return this; }
      WrongAdapter& operator*() { return *this; }
      operator WrongAdapter*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static WrongAdapter *_downcast( CORBA::Exception *ex );
      static const WrongAdapter *_downcast( const CORBA::Exception *ex );
    };


    typedef WrongAdapter WrongAdapter_catch;






    static CORBA::TypeCodeConst _tc_WrongAdapter;

    struct WrongPolicy : public CORBA::UserException {
# 1133 "../include/mico/poa.h"
      WrongPolicy *operator->() { return this; }
      WrongPolicy& operator*() { return *this; }
      operator WrongPolicy*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static WrongPolicy *_downcast( CORBA::Exception *ex );
      static const WrongPolicy *_downcast( const CORBA::Exception *ex );
    };


    typedef WrongPolicy WrongPolicy_catch;






    static CORBA::TypeCodeConst _tc_WrongPolicy;

    virtual char* the_name() = 0;
    virtual POA_ptr the_parent() = 0;
    virtual POAManager_ptr the_POAManager() = 0;
    virtual POAList* the_children() = 0;
    virtual AdapterActivator_ptr the_activator() = 0;
    virtual void the_activator( AdapterActivator_ptr value ) = 0;

    virtual POA_ptr create_POA( const char* adapter_name, POAManager_ptr a_POAManager, const CORBA::PolicyList& policies ) = 0;
    virtual POA_ptr find_POA( const char* adapter_name, CORBA::Boolean activate_it ) = 0;
    virtual void destroy( CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion ) = 0;
    virtual ThreadPolicy_ptr create_thread_policy( ThreadPolicyValue value ) = 0;
    virtual LifespanPolicy_ptr create_lifespan_policy( LifespanPolicyValue value ) = 0;
    virtual IdUniquenessPolicy_ptr create_id_uniqueness_policy( IdUniquenessPolicyValue value ) = 0;
    virtual IdAssignmentPolicy_ptr create_id_assignment_policy( IdAssignmentPolicyValue value ) = 0;
    virtual ImplicitActivationPolicy_ptr create_implicit_activation_policy( ImplicitActivationPolicyValue value ) = 0;
    virtual ServantRetentionPolicy_ptr create_servant_retention_policy( ServantRetentionPolicyValue value ) = 0;
    virtual RequestProcessingPolicy_ptr create_request_processing_policy( RequestProcessingPolicyValue value ) = 0;
    virtual ServantManager_ptr get_servant_manager() = 0;
    virtual void set_servant_manager( ServantManager_ptr imgr ) = 0;
    virtual Servant get_servant() = 0;
    virtual void set_servant( Servant p_servant ) = 0;
    virtual ObjectId* activate_object( Servant p_servant ) = 0;
    virtual void activate_object_with_id( const ObjectId& id, Servant p_servant ) = 0;
    virtual void deactivate_object( const ObjectId& oid ) = 0;
    virtual CORBA::Object_ptr create_reference( const char* intf ) = 0;
    virtual CORBA::Object_ptr create_reference_with_id( const ObjectId& oid, const char* intf ) = 0;
    virtual ObjectId* servant_to_id( Servant p_servant ) = 0;
    virtual CORBA::Object_ptr servant_to_reference( Servant p_servant ) = 0;
    virtual Servant reference_to_servant( CORBA::Object_ptr reference ) = 0;
    virtual ObjectId* reference_to_id( CORBA::Object_ptr reference ) = 0;
    virtual Servant id_to_servant( const ObjectId& oid ) = 0;
    virtual CORBA::Object_ptr id_to_reference( const ObjectId& oid ) = 0;
    virtual CORBA::Object_ptr activate_for_this( Servant serv ) = 0;
    virtual void poa_manager_callback( POAManager::State newstate, CORBA::Boolean etherealize_objects, CORBA::Boolean wait_for_completion ) = 0;
    virtual Servant preinvoke( CORBA::Object_ptr for_obj ) = 0;
    virtual void postinvoke() = 0;

  protected:
    POA() {};
  private:
    POA( const POA& );
    void operator=( const POA& );
};


class Current;
typedef Current *Current_ptr;
typedef Current_ptr CurrentRef;
typedef ObjVar<Current> Current_var;
typedef ObjOut<Current> Current_out;



class Current :
  virtual public ::CORBA::Current
{
  public:
    typedef ::CORBA::Current _VCHACK__CORBA__Current;
    virtual ~Current();


    typedef Current_ptr _ptr_type;
    typedef Current_var _var_type;


    static Current_ptr _narrow( CORBA::Object_ptr obj );
    static Current_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Current_ptr _duplicate( Current_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Current_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct NoContext : public CORBA::UserException {
# 1247 "../include/mico/poa.h"
      NoContext *operator->() { return this; }
      NoContext& operator*() { return *this; }
      operator NoContext*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static NoContext *_downcast( CORBA::Exception *ex );
      static const NoContext *_downcast( const CORBA::Exception *ex );
    };


    typedef NoContext NoContext_catch;






    static CORBA::TypeCodeConst _tc_NoContext;

    virtual POA_ptr get_POA() = 0;
    virtual ObjectId* get_object_id() = 0;
    virtual CORBA::Object_ptr make_ref() = 0;
    virtual CORBA::Boolean iscurrent() = 0;
    virtual Servant get_serv() = 0;

  protected:
    Current() {};
  private:
    Current( const Current& );
    void operator=( const Current& );
};






}
# 1300 "../include/mico/poa.h"
void operator<<=( CORBA::Any &a, const ::PortableServer::ForwardRequest &e );
void operator<<=( CORBA::Any &a, ::PortableServer::ForwardRequest *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::ForwardRequest &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::ForwardRequest *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_ForwardRequest;

void operator<<=( CORBA::Any &a, const ::PortableServer::ThreadPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::ThreadPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_ThreadPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::LifespanPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::LifespanPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_LifespanPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::IdUniquenessPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::IdUniquenessPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_IdUniquenessPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::IdAssignmentPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::IdAssignmentPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_IdAssignmentPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::ImplicitActivationPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::ImplicitActivationPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_ImplicitActivationPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::ServantRetentionPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::ServantRetentionPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_ServantRetentionPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::RequestProcessingPolicyValue &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::RequestProcessingPolicyValue &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_RequestProcessingPolicyValue;

void operator<<=( CORBA::Any &a, const ::PortableServer::POAManager::AdapterInactive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POAManager::AdapterInactive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POAManager::AdapterInactive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POAManager::AdapterInactive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POAManager_AdapterInactive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POAManager::State &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POAManager::State &e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POAManager_State;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::AdapterAlreadyExists &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::AdapterAlreadyExists *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::AdapterAlreadyExists &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::AdapterAlreadyExists *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterAlreadyExists;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::AdapterInactive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::AdapterInactive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::AdapterInactive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::AdapterInactive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterInactive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::AdapterNonExistent &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::AdapterNonExistent *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::AdapterNonExistent &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::AdapterNonExistent *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterNonExistent;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::InvalidPolicy &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::InvalidPolicy *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::InvalidPolicy &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::InvalidPolicy *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_InvalidPolicy;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::NoServant &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::NoServant *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::NoServant &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::NoServant *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_NoServant;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::ObjectAlreadyActive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::ObjectAlreadyActive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::ObjectAlreadyActive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::ObjectAlreadyActive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ObjectAlreadyActive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::ObjectNotActive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::ObjectNotActive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::ObjectNotActive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::ObjectNotActive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ObjectNotActive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::ServantAlreadyActive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::ServantAlreadyActive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::ServantAlreadyActive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::ServantAlreadyActive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ServantAlreadyActive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::ServantNotActive &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::ServantNotActive *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::ServantNotActive &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::ServantNotActive *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ServantNotActive;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::WrongAdapter &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::WrongAdapter *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::WrongAdapter &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::WrongAdapter *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_WrongAdapter;

void operator<<=( CORBA::Any &a, const ::PortableServer::POA::WrongPolicy &e );
void operator<<=( CORBA::Any &a, ::PortableServer::POA::WrongPolicy *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::POA::WrongPolicy &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::POA::WrongPolicy *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_WrongPolicy;

void operator<<=( CORBA::Any &a, const ::PortableServer::Current::NoContext &e );
void operator<<=( CORBA::Any &a, ::PortableServer::Current::NoContext *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::PortableServer::Current::NoContext &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::PortableServer::Current::NoContext *&e );

extern CORBA::StaticTypeInfo *_marshaller_PortableServer_Current_NoContext;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_PortableServer_POA;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,3> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::Octet,3> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::Octet,3> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,3> *&_s );





# 1 "../include/mico/template_impl.h" 1
# 1477 "../include/mico/poa.h" 2
# 212 "../include/CORBA.h" 2
# 1 "../include/mico/poa_base.h" 1
# 28 "../include/mico/poa_base.h"
namespace PortableServer {




extern POA * _the_root_poa;
extern Current * _the_poa_current;

class ServantBase
{
public:
  virtual ~ServantBase ();

  virtual POA_ptr _default_POA();
  virtual CORBA::Boolean _is_a (const char *);
  virtual CORBA::Boolean _non_existent ();
  virtual CORBA::InterfaceDef_ptr _get_interface () = 0;


  CORBA::InterfaceDef_ptr _get_interface (const char *repoid);
  CORBA::Object_ptr _this ();
  virtual char * _primary_interface (const ObjectId &,
                                     POA_ptr) = 0;


  virtual void _add_ref ();
  virtual void _remove_ref ();


  virtual void _check ();
  virtual void * _narrow_helper (const char *);
  virtual CORBA::Object_ptr _make_stub (POA_ptr, CORBA::Object_ptr);
  virtual CORBA::ServerRequestBase_ptr make_request (CORBA::ORBRequest *,
                                                     CORBA::Object_ptr,
                                                     CORBA::ULong,
                                                     CORBA::ObjectAdapter *,
                                                     CORBA::Principal_ptr) = 0;
  virtual void doinvoke (CORBA::ServerRequestBase_ptr) = 0;

  POA_ptr _activated_in ();
  void _activated_in (POA_ptr);


protected:
  ServantBase ();
  ServantBase (const ServantBase &);
  ServantBase & operator= (const ServantBase &);
  POA_ptr _my_poa;
};

class RefCountServantBase : virtual public ServantBase
{
public:
  virtual ~RefCountServantBase ();

  virtual void _add_ref ();
  virtual void _remove_ref ();


  void _check ();


protected:
  RefCountServantBase ();
  RefCountServantBase (const RefCountServantBase &);
  RefCountServantBase & operator= (const RefCountServantBase &);

private:
  CORBA::ULong _magic;
  CORBA::ULong _ref_count;
};

class ValueRefCountBase :
  virtual public CORBA::DefaultValueRefCountBase,
  virtual public ServantBase
{
public:
  ValueRefCountBase ();
  virtual ~ValueRefCountBase ();

  virtual void _add_ref ();
  virtual void _remove_ref ();
  virtual CORBA::ULong _refcount_value ();

protected:
  ValueRefCountBase (const ValueRefCountBase &);

private:
  void operator= (const ValueRefCountBase &);
};

class DynamicImplementation : virtual public ServantBase
{
public:
  virtual ~DynamicImplementation ();

  CORBA::Object_ptr _this ();
  virtual void invoke (CORBA::ServerRequest_ptr) = 0;
  virtual char * _primary_interface (const ObjectId &,
                                     POA_ptr) = 0;





  CORBA::Boolean _is_a (const char *);
  CORBA::InterfaceDef_ptr _get_interface ();


  CORBA::ServerRequestBase_ptr make_request (CORBA::ORBRequest *,
                                             CORBA::Object_ptr,
                                             CORBA::ULong,
                                             CORBA::ObjectAdapter *,
                                             CORBA::Principal_ptr);
  void doinvoke (CORBA::ServerRequestBase_ptr);

};


class StaticImplementation : virtual public ServantBase
{
public:
  virtual ~StaticImplementation ();
  virtual void invoke (CORBA::StaticServerRequest_ptr) = 0;
  CORBA::ServerRequestBase_ptr make_request (CORBA::ORBRequest *,
                                             CORBA::Object_ptr,
                                             CORBA::ULong,
                                             CORBA::ObjectAdapter *,
                                             CORBA::Principal_ptr);
  virtual void doinvoke (CORBA::ServerRequestBase_ptr);
};


typedef ValueVar<ServantBase> ServantBase_var;


class StubBase : virtual public CORBA::Object {
public:
  StubBase (POA_ptr);
  virtual ~StubBase ();

  ServantBase * _preinvoke ();
  void _postinvoke ();

protected:
  StubBase ();

private:
  POA_ptr _colocated_poa;
};


extern char * ObjectId_to_string (const ObjectId &);
extern CORBA::WChar * ObjectId_to_wstring (const ObjectId &);
extern ObjectId * string_to_ObjectId (const char *);
extern ObjectId * wstring_to_ObjectId (const CORBA::WChar *);




}
# 201 "../include/mico/poa_base.h"
template<class T>
class POA_Tie_Base
{
protected:
  T * ptr;
  PortableServer::POA_ptr poa;
  CORBA::Boolean rel;

  POA_Tie_Base () {}

public:
  POA_Tie_Base (T *t, PortableServer::POA_ptr _poa, CORBA::Boolean _rel)
  {
    ptr = t;
    poa = PortableServer::POA::_duplicate (_poa);
    rel = _rel;
  }

  virtual ~POA_Tie_Base ()
  {
    if (rel) delete ptr;
    CORBA::release (poa);
  }

  T * _tied_object ()
  {
    return ptr;
  }

  void _tied_object (T &t)
  {
    if (rel) delete ptr;
    ptr = &t;
    rel = 0;
  }

  void _tied_object (T *t, CORBA::Boolean r = 1)
  {
    if (rel) delete ptr;
    ptr = t;
    rel = r;
  }

  CORBA::Boolean _is_owner ()
  {
    return rel;
  }

  void _is_owner (CORBA::Boolean _rel)
  {
    rel = _rel;
  }
};
# 213 "../include/CORBA.h" 2
# 1 "../include/mico/poa_stubs.h" 1
# 40 "../include/mico/poa_stubs.h"
namespace PortableServer {




class AdapterActivator_stub_clp :
  virtual public AdapterActivator,
  virtual public PortableServer::StubBase
{
  public:
    AdapterActivator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~AdapterActivator_stub_clp ();
    CORBA::Boolean unknown_adapter( POA_ptr parent, const char* name );
  private:
    void operator=( const AdapterActivator_stub_clp & );
};

class ServantManager_stub_clp :
  virtual public ServantManager,
  virtual public PortableServer::StubBase
{
  public:
    ServantManager_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ServantManager_stub_clp ();
  private:
    void operator=( const ServantManager_stub_clp & );
};

class ServantActivator_stub_clp :
  virtual public ServantActivator,
  virtual public ::PortableServer::ServantManager_stub_clp
{
  public:
    ServantActivator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ServantActivator_stub_clp ();
    ::PortableServer::Servant incarnate( const ObjectId& oid, POA_ptr adapter );
    void etherealize( const ObjectId& oid, POA_ptr adapter, ::PortableServer::Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations );
  private:
    void operator=( const ServantActivator_stub_clp & );
};

class ServantLocator_stub_clp :
  virtual public ServantLocator,
  virtual public ::PortableServer::ServantManager_stub_clp
{
  public:
    ServantLocator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ServantLocator_stub_clp ();
    ::PortableServer::Servant preinvoke( const ObjectId& oid, POA_ptr adapter, const char* operation, Cookie& the_cookie );
    void postinvoke( const ObjectId& oid, POA_ptr adapter, const char* operation, Cookie the_cookie, ::PortableServer::Servant the_servant );
  private:
    void operator=( const ServantLocator_stub_clp & );
};




}



namespace POA_PortableServer {




class AdapterActivator : virtual public PortableServer::DynamicImplementation
{
  public:
    virtual ~AdapterActivator ();
    PortableServer::AdapterActivator_ptr _this ();
    bool dispatch (CORBA::ServerRequest_ptr);
    virtual void invoke (CORBA::ServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual char * _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static AdapterActivator * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::Boolean unknown_adapter( PortableServer::POA_ptr parent, const char* name ) = 0;

  protected:
    AdapterActivator () {};

  private:
    AdapterActivator (const AdapterActivator &);
    void operator= (const AdapterActivator &);
};

class ServantManager : virtual public PortableServer::DynamicImplementation
{
  public:
    virtual ~ServantManager ();
    PortableServer::ServantManager_ptr _this ();
    bool dispatch (CORBA::ServerRequest_ptr);
    virtual void invoke (CORBA::ServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual char * _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ServantManager * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);


  protected:
    ServantManager () {};

  private:
    ServantManager (const ServantManager &);
    void operator= (const ServantManager &);
};

class ServantActivator :
  virtual public POA_PortableServer::ServantManager
{
  public:
    virtual ~ServantActivator ();
    PortableServer::ServantActivator_ptr _this ();
    bool dispatch (CORBA::ServerRequest_ptr);
    virtual void invoke (CORBA::ServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual char * _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ServantActivator * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual PortableServer::Servant incarnate( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter ) = 0;
    virtual void etherealize( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, PortableServer::Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations ) = 0;

  protected:
    ServantActivator () {};

  private:
    ServantActivator (const ServantActivator &);
    void operator= (const ServantActivator &);
};

class ServantLocator :
  virtual public POA_PortableServer::ServantManager
{
  public:
    virtual ~ServantLocator ();
    PortableServer::ServantLocator_ptr _this ();
    bool dispatch (CORBA::ServerRequest_ptr);
    virtual void invoke (CORBA::ServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual char * _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ServantLocator * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual PortableServer::Servant preinvoke( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie& the_cookie ) = 0;
    virtual void postinvoke( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant ) = 0;

  protected:
    ServantLocator () {};

  private:
    ServantLocator (const ServantLocator &);
    void operator= (const ServantLocator &);
};




}
# 214 "../include/CORBA.h" 2


# 1 "../include/mico/tckind.h" 1
# 12 "../include/mico/tckind.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/tckind.h" 2



namespace CORBA {





enum TCKind {
  tk_null = 0,
  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_local_interface
};

typedef TCKind& TCKind_out;





}
# 80 "../include/mico/tckind.h"
# 1 "../include/mico/template_impl.h" 1
# 81 "../include/mico/tckind.h" 2
# 217 "../include/CORBA.h" 2
# 1 "../include/mico/ir_base.h" 1







# 1 "../include/CORBA.h" 1
# 9 "../include/mico/ir_base.h" 2





namespace CORBA {


typedef char* Identifier;
typedef CORBA::String_var Identifier_var;
typedef CORBA::String_out Identifier_out;

extern CORBA::TypeCodeConst _tc_Identifier;

typedef char* VersionSpec;
typedef CORBA::String_var VersionSpec_var;
typedef CORBA::String_out VersionSpec_out;

extern CORBA::TypeCodeConst _tc_VersionSpec;

typedef char* RepositoryId;
typedef CORBA::String_var RepositoryId_var;
typedef CORBA::String_out RepositoryId_out;

extern CORBA::TypeCodeConst _tc_RepositoryId;

enum DefinitionKind {
  dk_none = 0,
  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_AbstractInterface,
  dk_LocalInterface,
  dk_Component,
  dk_Home,
  dk_Factory,
  dk_Finder,
  dk_PrimaryKey,
  dk_Emits,
  dk_Publishes,
  dk_Consumes,
  dk_Provides,
  dk_Uses
};

typedef DefinitionKind& DefinitionKind_out;

extern CORBA::TypeCodeConst _tc_DefinitionKind;

class IRObject;
typedef IRObject *IRObject_ptr;
typedef IRObject_ptr IRObjectRef;
typedef ObjVar<IRObject> IRObject_var;
typedef ObjOut<IRObject> IRObject_out;



class IRObject :
  virtual public CORBA::Object
{
  public:
    virtual ~IRObject();


    typedef IRObject_ptr _ptr_type;
    typedef IRObject_var _var_type;


    static IRObject_ptr _narrow( CORBA::Object_ptr obj );
    static IRObject_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static IRObject_ptr _duplicate( IRObject_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static IRObject_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual DefinitionKind def_kind() = 0;

    virtual void destroy() = 0;

  protected:
    IRObject() {};
  private:
    IRObject( const IRObject& );
    void operator=( const IRObject& );
};

extern CORBA::TypeCodeConst _tc_IRObject;


class IRObject_stub:
  virtual public IRObject
{
  public:
    virtual ~IRObject_stub();
    DefinitionKind def_kind();

    void destroy();

  private:
    void operator=( const IRObject_stub& );
};



class IRObject_stub_clp :
  virtual public IRObject_stub,
  virtual public PortableServer::StubBase
{
  public:
    IRObject_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~IRObject_stub_clp ();
    DefinitionKind def_kind();

    void destroy();

  protected:
    IRObject_stub_clp ();
  private:
    void operator=( const IRObject_stub_clp & );
};



class IDLType;
typedef IDLType *IDLType_ptr;
typedef IDLType_ptr IDLTypeRef;
typedef ObjVar<IDLType> IDLType_var;
typedef ObjOut<IDLType> IDLType_out;



class IDLType :
  virtual public ::CORBA::IRObject
{
  public:
    typedef ::CORBA::IRObject _VCHACK__CORBA__IRObject;
    virtual ~IDLType();


    typedef IDLType_ptr _ptr_type;
    typedef IDLType_var _var_type;


    static IDLType_ptr _narrow( CORBA::Object_ptr obj );
    static IDLType_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static IDLType_ptr _duplicate( IDLType_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static IDLType_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr type() = 0;

  protected:
    IDLType() {};
  private:
    IDLType( const IDLType& );
    void operator=( const IDLType& );
};

extern CORBA::TypeCodeConst _tc_IDLType;


class IDLType_stub:
  virtual public IDLType,
  virtual public ::CORBA::IRObject_stub
{
  public:
    virtual ~IDLType_stub();
    CORBA::TypeCode_ptr type();

  private:
    void operator=( const IDLType_stub& );
};



class IDLType_stub_clp :
  virtual public IDLType_stub,
  virtual public ::CORBA::IRObject_stub_clp
{
  public:
    IDLType_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~IDLType_stub_clp ();
    CORBA::TypeCode_ptr type();

  protected:
    IDLType_stub_clp ();
  private:
    void operator=( const IDLType_stub_clp & );
};



struct StructMember;
typedef TVarVar<StructMember> StructMember_var;
typedef TVarOut<StructMember> StructMember_out;

struct StructMember {

  typedef StructMember_var _var_type;
# 253 "../include/mico/ir_base.h"
  Identifier_var name;
  CORBA::TypeCode_var type;
  IDLType_var type_def;
};

extern CORBA::TypeCodeConst _tc_StructMember;

typedef SequenceTmpl<StructMember,0> StructMemberSeq;



typedef TSeqVar<SequenceTmpl<StructMember,0> > StructMemberSeq_var;
typedef TSeqOut<SequenceTmpl<StructMember,0> > StructMemberSeq_out;

extern CORBA::TypeCodeConst _tc_StructMemberSeq;

struct UnionMember;
typedef TVarVar<UnionMember> UnionMember_var;
typedef TVarOut<UnionMember> UnionMember_out;

struct UnionMember {

  typedef UnionMember_var _var_type;
# 284 "../include/mico/ir_base.h"
  Identifier_var name;
  CORBA::Any label;
  CORBA::TypeCode_var type;
  IDLType_var type_def;
};

extern CORBA::TypeCodeConst _tc_UnionMember;

typedef SequenceTmpl<UnionMember,0> UnionMemberSeq;



typedef TSeqVar<SequenceTmpl<UnionMember,0> > UnionMemberSeq_var;
typedef TSeqOut<SequenceTmpl<UnionMember,0> > UnionMemberSeq_out;

extern CORBA::TypeCodeConst _tc_UnionMemberSeq;

typedef StringSequenceTmpl<CORBA::String_var> EnumMemberSeq;



typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > EnumMemberSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > EnumMemberSeq_out;

extern CORBA::TypeCodeConst _tc_EnumMemberSeq;

typedef CORBA::Short Visibility;
typedef Visibility& Visibility_out;
extern CORBA::TypeCodeConst _tc_Visibility;

extern const CORBA::Short PRIVATE_MEMBER;
extern const CORBA::Short PUBLIC_MEMBER;
typedef CORBA::Short ValueModifier;
typedef ValueModifier& ValueModifier_out;
extern CORBA::TypeCodeConst _tc_ValueModifier;

extern const CORBA::Short VM_NONE;
extern const CORBA::Short VM_CUSTOM;
extern const CORBA::Short VM_ABSTRACT;
extern const CORBA::Short VM_TRUNCATABLE;
struct ValueMember;
typedef TVarVar<ValueMember> ValueMember_var;
typedef TVarOut<ValueMember> ValueMember_out;

struct ValueMember {

  typedef ValueMember_var _var_type;
# 339 "../include/mico/ir_base.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var type;
  IDLType_var type_def;
  Visibility access;
};

extern CORBA::TypeCodeConst _tc_ValueMember;

typedef SequenceTmpl<ValueMember,0> ValueMemberSeq;



typedef TSeqVar<SequenceTmpl<ValueMember,0> > ValueMemberSeq_var;
typedef TSeqOut<SequenceTmpl<ValueMember,0> > ValueMemberSeq_out;

extern CORBA::TypeCodeConst _tc_ValueMemberSeq;

}




namespace POA_CORBA {


class IRObject : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~IRObject ();
    CORBA::IRObject_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static IRObject * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::DefinitionKind def_kind() = 0;

    virtual void destroy() = 0;

  protected:
    IRObject () {};

  private:
    IRObject (const IRObject &);
    void operator= (const IRObject &);
};

class IDLType :
  virtual public POA_CORBA::IRObject
{
  public:
    virtual ~IDLType ();
    CORBA::IDLType_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static IDLType * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr type() = 0;

  protected:
    IDLType () {};

  private:
    IDLType (const IDLType &);
    void operator= (const IDLType &);
};

}




void operator<<=( CORBA::Any &a, const ::CORBA::DefinitionKind &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::DefinitionKind &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_DefinitionKind;

void operator<<=( CORBA::Any &a, const CORBA::IRObject_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::IRObject_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::IRObject_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_IRObject;

void operator<<=( CORBA::Any &a, const CORBA::IDLType_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::IDLType_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::IDLType_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_IDLType;

void operator<<=( CORBA::Any &_a, const ::CORBA::StructMember &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::StructMember *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::StructMember &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::StructMember *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_StructMember;

void operator<<=( CORBA::Any &_a, const ::CORBA::UnionMember &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::UnionMember *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::UnionMember &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::UnionMember *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_UnionMember;

void operator<<=( CORBA::Any &_a, const ::CORBA::ValueMember &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ValueMember *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ValueMember &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ValueMember *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueMember;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::StructMember,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::StructMember,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::StructMember,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::StructMember,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_StructMember;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::UnionMember,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::UnionMember,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::UnionMember,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::UnionMember,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_UnionMember;

void operator<<=( CORBA::Any &_a, const StringSequenceTmpl<CORBA::String_var> &_s );
void operator<<=( CORBA::Any &_a, StringSequenceTmpl<CORBA::String_var> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, StringSequenceTmpl<CORBA::String_var> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const StringSequenceTmpl<CORBA::String_var> *&_s );

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ValueMember,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ValueMember,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ValueMember,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ValueMember,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ValueMember;
# 218 "../include/CORBA.h" 2
# 1 "../include/mico/typecode.h" 1
# 27 "../include/mico/typecode.h"
namespace CORBA {

class TypeCode : public ServerlessObject {
    TCKind tckind;
    string repoid;
    string tcname;
    vector<string> namevec;
    vector<TypeCode_ptr> tcvec;
    vector<Any *> labelvec;
    vector<Visibility> visvec;
    TypeCode_ptr content;
    TypeCode_ptr discriminator;
    TypeCode_ptr recurse_tc;
    Long defidx;
    Long len;
    Long recurse_depth;
    Boolean isconst;
    UShort digits;
    Short scale;
    ValueModifier value_mod;

    void init ();
    void copy (const TypeCode &);
    void free ();

    typedef pair<TypeCode_ptr, TypeCode_ptr> PairTC;
    typedef set<PairTC, less<PairTC> > SetTC;
    typedef map<ULong, pair<ULong, TypeCode_ptr>, less<ULong> > MapPosTC;
    typedef map<const TypeCode *, ULong, less<const TypeCode *> > MapTCPos;

    TypeCode_ptr resolve_recursion() const;
    void strip();
    void connect (TypeCode_ptr, Long depth = 0);
    CORBA::ULong get_recurse_depth();
    static CORBA::Any *convert_case_label (CORBA::TypeCode_ptr disc,
                                           const CORBA::Any &);
public:

    void disconnect (TypeCode_ptr);
    TypeCode (const string &);
    TypeCode ();
    ~TypeCode ();
    TypeCode (TCKind);
    TypeCode (const TypeCode &);
    TypeCode (DataDecoder &);
    TypeCode &operator= (const TypeCode &);
    Boolean from_string (const char *);

    static TypeCode_ptr create_basic_tc (TCKind);
    static TypeCode_ptr create_struct_tc (const char *rep_id, const char *name,
                                          const StructMemberSeq &members);
    static TypeCode_ptr create_exception_tc (const char *rep_id,
                                             const char *name,
                                             const StructMemberSeq &members);
    static TypeCode_ptr create_union_tc (const char *rep_id, const char *name,
                                         TypeCode_ptr disc_type,
                                         const UnionMemberSeq &members);
    static TypeCode_ptr create_enum_tc (const char *rep_id, const char *name,
                                        const EnumMemberSeq &members);
    static TypeCode_ptr create_alias_tc (const char *rep_id, const char *name,
                                         TypeCode_ptr orig_type);
    static TypeCode_ptr create_interface_tc (const char *rep_id,
                                             const char *name);
    static TypeCode_ptr create_string_tc (ULong bound);
    static TypeCode_ptr create_wstring_tc (ULong bound);
    static TypeCode_ptr create_sequence_tc (ULong bound, TypeCode_ptr el_type);
    static TypeCode_ptr create_array_tc (ULong bound, TypeCode_ptr el_type);
    static TypeCode_ptr create_recursive_sequence_tc (ULong bound,
                                                      ULong offset);
    static TypeCode_ptr create_fixed_tc (UShort digits, Short scale);
    static TypeCode_ptr create_value_tc (const char *rep_id, const char *name,
                                         ValueModifier mod,
                                         TypeCode_ptr concrete_base,
                                         const ValueMemberSeq &members);
    static TypeCode_ptr create_value_box_tc (const char *rep_id,
                                             const char *name,
                                             TypeCode_ptr boxed_type);
    static TypeCode_ptr create_native_tc (const char *rep_id,
                                          const char *name);
    static TypeCode_ptr create_recursive_tc (const char *rep_id);
    static TypeCode_ptr create_abstract_interface_tc (const char *rep_id,
                                                      const char *name);
    static TypeCode_ptr create_local_interface_tc (const char *rep_id,
                                                   const char *name);


    typedef CORBA::TypeCode_Bounds Bounds;
    typedef CORBA::TypeCode_Bounds_catch Bounds_catch;

    typedef CORBA::TypeCode_BadKind BadKind;
    typedef CORBA::TypeCode_BadKind_catch BadKind_catch;

    TCKind kind () const;
    Boolean equal (TypeCode_ptr, Boolean remove_aliases = 0,
                                 Boolean ignore_string_bounds = 0) const;
    Boolean equaltype (TypeCode_ptr, SetTC * = 0);
    Boolean equivalent (TypeCode_ptr tc);

    const char *id () const;
    const char *name () const;

    Long member_index (const Any &);
    Long member_index (const char *);
    ULong member_count () const;
    const char *member_name (ULong idx) const;
    TypeCode_ptr member_type (ULong idx) const;
    Any *member_label (ULong idx) const;
    TypeCode_ptr discriminator_type () const;
    Long default_index () const;

    ULong length () const;

    TypeCode_ptr content_type () const;

    UShort fixed_digits () const;
    Short fixed_scale () const;

    Visibility member_visibility (ULong idx) const;
    ValueModifier type_modifier() const;
    TypeCode_ptr concrete_base_type() const;
    TypeCode_ptr get_compact_typecode() const;

    ULong member_count_inherited () const;
    const char *member_name_inherited (ULong idx) const;
    TypeCode_ptr member_type_inherited (ULong idx) const;
    Visibility member_visibility_inherited (ULong idx) const;

    Long param_count () const;
    Any *parameter (Long) const;


    ULong array_size ();
    TypeCode_ptr array_type ();
    Boolean is_constant () const;
    TypeCode_ptr mk_constant ();
    TypeCode_ptr unalias ();

    void encode (DataEncoder &, MapTCPos * = __null) const;
    Boolean decode (DataDecoder &, MapPosTC * = __null, ULong level = 0);

    string stringify () const;

    Boolean is_recursive_seq ();
    Boolean is_freestanding();
    Boolean is_freestanding( ULong depth, TypeCode_ptr tc );


    Boolean is_base_type();
    Boolean is_char();
    Boolean is_wchar();
    Boolean is_octet();
    Boolean is_bool();
    Boolean is_enum();
    Boolean is_string();
    Boolean is_wstring();
    Boolean is_any();
    Boolean is_type_code();
    Boolean is_alias();
    Boolean is_variable();
    Boolean is_objref();
    Boolean is_object();
    Boolean is_sequence();
    Boolean is_array();
    Boolean is_valuetype();
    Boolean is_native();
    Boolean is_abstract_interface();


    static TypeCode_ptr _duplicate (TypeCode_ptr);
    static TypeCode_ptr _nil ()
    {
        return 0;
    }
};
extern void release (TypeCode_ptr);





class LevelRecord {
public:
    enum Level {
        LNone, LArray, LSequence, LStruct, LExcept, LUnion, LValue, LValueBox
    };
private:
    TypeCode_ptr _tc;
    Level _level;
public:
    Long i, n, x, last_i;

    LevelRecord (Level, TypeCode_ptr, Long n = 0, Long i = 0, Long x = 0);
    LevelRecord (const LevelRecord &);
    LevelRecord ();
    ~LevelRecord ();
    LevelRecord &operator= (const LevelRecord &);
    Level level () const;
    TypeCode_ptr tc ();
};

class TypeCodeChecker {
    TypeCode_ptr _top;
    TypeCode_ptr _tc;
    Boolean done;
    vector<LevelRecord> levelvec;

    LevelRecord *level ();
    Boolean advance ();
    Boolean nexttc ();
    Boolean leave (LevelRecord::Level, Boolean sloppy = 0);
    void enter (const LevelRecord &);
    void tc (TypeCode_ptr);
    void override_tc (TypeCode_ptr);
public:
    TypeCodeChecker ();
    TypeCodeChecker (TypeCode_ptr);
    TypeCodeChecker (const TypeCodeChecker &);
    TypeCodeChecker &operator= (const TypeCodeChecker &);
    ~TypeCodeChecker ();

    TypeCode_ptr tc ();
    Boolean inside (TCKind);
    Boolean level_finished ();

    Boolean basic (TypeCode_ptr);
    Boolean enumeration (Long val);
    Boolean abstract_interface (TypeCode_ptr override);

    Boolean union_begin ();
    Boolean union_selection (Long idx = -1L);
    Boolean union_end (Boolean sloppy = 0);

    Boolean struct_begin ();
    Boolean struct_end (Boolean sloppy = 0);

    Boolean except_begin ();
    Boolean except_end (Boolean sloppy = 0);

    Boolean seq_begin (ULong len);
    Boolean seq_end (Boolean sloppy = 0);

    Boolean arr_begin ();
    Boolean arr_end (Boolean sloppy = 0);

    Boolean value_begin (TypeCode_ptr override = 0);
    Boolean value_end ();

    Boolean valuebox_begin ();
    Boolean valuebox_end ();

    void finish ();
    Boolean completed () const;
    void restart (TypeCode_ptr);
    void restart ();
    ULong level_count () const;
};



extern TypeCode_ptr _tc_null;
extern TypeCode_ptr _tc_void;
extern TypeCode_ptr _tc_short;
extern TypeCode_ptr _tc_long;
extern TypeCode_ptr _tc_longlong;
extern TypeCode_ptr _tc_ushort;
extern TypeCode_ptr _tc_ulong;
extern TypeCode_ptr _tc_ulonglong;
extern TypeCode_ptr _tc_float;
extern TypeCode_ptr _tc_double;
extern TypeCode_ptr _tc_longdouble;
extern TypeCode_ptr _tc_boolean;
extern TypeCode_ptr _tc_char;
extern TypeCode_ptr _tc_wchar;
extern TypeCode_ptr _tc_octet;
extern TypeCode_ptr _tc_any;
extern TypeCode_ptr _tc_TypeCode;
extern TypeCode_ptr _tc_Principal;
extern TypeCode_ptr _tc_Context;
extern TypeCode_ptr _tc_NamedValue;
extern TypeCode_ptr _tc_Object;
extern TypeCode_ptr _tc_ValueBase;
extern TypeCode_ptr _tc_AbstractBase;
extern TypeCode_ptr _tc_string;
extern TypeCode_ptr _tc_wstring;

}
# 219 "../include/CORBA.h" 2
# 1 "../include/mico/valuetype.h" 1
# 12 "../include/mico/valuetype.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/valuetype.h" 2



namespace CORBA {







class StringValue :
  virtual public CORBA::ValueBase,
  virtual public CORBA::DefaultValueRefCountBase
{
  private:
    CORBA::String_var value;

  public:
    StringValue ();
    StringValue (char *);
    StringValue (const char *);
    StringValue (const CORBA::String_var &);
    StringValue (const StringValue &);

    StringValue & operator= (char *);
    StringValue & operator= (const char *);
    StringValue & operator= (const CORBA::String_var &);

    const char * _value () const;
    void _value (char *);
    void _value (const char *);
    void _value (const CORBA::String_var &);

    char & operator[] (CORBA::ULong);
    char operator[] (CORBA::ULong) const;

    const char* _boxed_in () const;
    char*& _boxed_inout ();
    char*& _boxed_out ();

    static StringValue* _downcast (CORBA::ValueBase *);
    static StringValue* _downcast (CORBA::AbstractBase *);

    CORBA::ValueBase * _copy_value ();
    CORBA::ValueDef_ptr get_value_def ();
    void * _narrow_helper (const char *);
    void _get_marshal_info (vector<string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    ~StringValue ();

  private:
    void operator= (const StringValue &);
};

typedef ValueVar<StringValue> StringValue_var;
typedef StringValue_var StringValue_out;

extern CORBA::TypeCodeConst _tc_StringValue;



class WStringValue :
  virtual public CORBA::ValueBase,
  virtual public CORBA::DefaultValueRefCountBase
{
  private:
    CORBA::WString_var value;

  public:
    WStringValue ();
    WStringValue (CORBA::WChar *);
    WStringValue (const CORBA::WChar *);
    WStringValue (const CORBA::WString_var &);
    WStringValue (const WStringValue &);

    WStringValue & operator= (CORBA::WChar *);
    WStringValue & operator= (const CORBA::WChar *);
    WStringValue & operator= (const CORBA::WString_var &);

    const CORBA::WChar * _value () const;
    void _value (CORBA::WChar *);
    void _value (const CORBA::WChar *);
    void _value (const CORBA::WString_var &);

    CORBA::WChar & operator[] (CORBA::ULong);
    CORBA::WChar operator[] (CORBA::ULong) const;

    const CORBA::WChar* _boxed_in () const;
    CORBA::WChar*& _boxed_inout ();
    CORBA::WChar*& _boxed_out ();

    static WStringValue* _downcast (CORBA::ValueBase *);
    static WStringValue* _downcast (CORBA::AbstractBase *);

    CORBA::ValueBase * _copy_value ();
    CORBA::ValueDef_ptr get_value_def ();
    void * _narrow_helper (const char *);
    void _get_marshal_info (vector<string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    ~WStringValue ();

  private:
    void operator= (const WStringValue &);
};

typedef ValueVar<WStringValue> WStringValue_var;
typedef WStringValue_var WStringValue_out;

extern CORBA::TypeCodeConst _tc_WStringValue;

class DataOutputStream;
typedef DataOutputStream *DataOutputStream_ptr;
typedef DataOutputStream_ptr DataOutputStreamRef;
typedef ValueVar<DataOutputStream> DataOutputStream_var;
typedef DataOutputStream_var DataOutputStream_out;

class DataInputStream;
typedef DataInputStream *DataInputStream_ptr;
typedef DataInputStream_ptr DataInputStreamRef;
typedef ValueVar<DataInputStream> DataInputStream_var;
typedef DataInputStream_var DataInputStream_out;

class CustomMarshal;
typedef CustomMarshal *CustomMarshal_ptr;
typedef CustomMarshal_ptr CustomMarshalRef;
typedef ValueVar<CustomMarshal> CustomMarshal_var;
typedef CustomMarshal_var CustomMarshal_out;



class CustomMarshal :
  virtual public CORBA::ValueBase
{
  public:
    static CustomMarshal* _downcast (CORBA::ValueBase *);
    static CustomMarshal* _downcast (CORBA::AbstractBase *);

    virtual void marshal( DataOutputStream* os ) = 0;
    virtual CORBA::ValueBase* unmarshal( DataInputStream* is ) = 0;

  public:
    CORBA::ValueDef_ptr get_value_def ();
    virtual void * _narrow_helper (const char *);
    void _get_marshal_info (vector<string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    CustomMarshal ();
    virtual ~CustomMarshal ();

  private:
    CustomMarshal (const CustomMarshal &);
    void operator= (const CustomMarshal &);
};

extern CORBA::TypeCodeConst _tc_CustomMarshal;



class DataOutputStream :
  virtual public CORBA::ValueBase
{
  public:
    static DataOutputStream* _downcast (CORBA::ValueBase *);
    static DataOutputStream* _downcast (CORBA::AbstractBase *);

    virtual void write_any( const CORBA::Any& value ) = 0;
    virtual void write_boolean( CORBA::Boolean value ) = 0;
    virtual void write_char( CORBA::Char value ) = 0;
    virtual void write_wchar( CORBA::WChar value ) = 0;
    virtual void write_octet( CORBA::Octet value ) = 0;
    virtual void write_short( CORBA::Short value ) = 0;
    virtual void write_ushort( CORBA::UShort value ) = 0;
    virtual void write_long( CORBA::Long value ) = 0;
    virtual void write_ulong( CORBA::ULong value ) = 0;
    virtual void write_longlong( CORBA::LongLong value ) = 0;
    virtual void write_ulonglong( CORBA::ULongLong value ) = 0;
    virtual void write_float( CORBA::Float value ) = 0;
    virtual void write_double( CORBA::Double value ) = 0;
    virtual void write_longdouble( CORBA::LongDouble value ) = 0;
    virtual void write_string( const char* value ) = 0;
    virtual void write_wstring( const CORBA::WChar* value ) = 0;
    virtual void write_Object( CORBA::Object_ptr value ) = 0;
    virtual void write_Abstract( CORBA::AbstractBase* value ) = 0;
    virtual void write_Value( CORBA::ValueBase* value ) = 0;
    virtual void write_TypeCode( CORBA::TypeCode_ptr value ) = 0;
    virtual void write_any_array( const AnySeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_boolean_array( const BooleanSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_char_array( const CharSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_wchar_array( const WCharSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_octet_array( const OctetSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_short_array( const ShortSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_ushort_array( const UShortSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_long_array( const LongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_ulong_array( const ULongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_longlong_array( const LongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_ulonglong_array( const ULongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_float_array( const FloatSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void write_double_array( const DoubleSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;

  public:
    CORBA::ValueDef_ptr get_value_def ();
    virtual void * _narrow_helper (const char *);
    void _get_marshal_info (vector<string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    DataOutputStream ();
    virtual ~DataOutputStream ();

  private:
    DataOutputStream (const DataOutputStream &);
    void operator= (const DataOutputStream &);
};

extern CORBA::TypeCodeConst _tc_DataOutputStream;



class DataInputStream :
  virtual public CORBA::ValueBase
{
  public:
    static DataInputStream* _downcast (CORBA::ValueBase *);
    static DataInputStream* _downcast (CORBA::AbstractBase *);

    virtual CORBA::Any* read_any() = 0;
    virtual CORBA::Boolean read_boolean() = 0;
    virtual CORBA::Char read_char() = 0;
    virtual CORBA::WChar read_wchar() = 0;
    virtual CORBA::Octet read_octet() = 0;
    virtual CORBA::Short read_short() = 0;
    virtual CORBA::UShort read_ushort() = 0;
    virtual CORBA::Long read_long() = 0;
    virtual CORBA::ULong read_ulong() = 0;
    virtual CORBA::LongLong read_longlong() = 0;
    virtual CORBA::ULongLong read_ulonglong() = 0;
    virtual CORBA::Float read_float() = 0;
    virtual CORBA::Double read_double() = 0;
    virtual CORBA::LongDouble read_longdouble() = 0;
    virtual char* read_string() = 0;
    virtual CORBA::WChar* read_wstring() = 0;
    virtual CORBA::Object_ptr read_Object() = 0;
    virtual CORBA::AbstractBase* read_Abstract() = 0;
    virtual CORBA::ValueBase* read_Value() = 0;
    virtual CORBA::TypeCode_ptr read_TypeCode() = 0;
    virtual void read_any_array( AnySeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_boolean_array( BooleanSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_char_array( CharSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_wchar_array( WCharSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_octet_array( OctetSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_short_array( ShortSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_ushort_array( UShortSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_long_array( LongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_ulong_array( ULongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_longlong_array( LongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_ulonglong_array( ULongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_float_array( FloatSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;
    virtual void read_double_array( DoubleSeq& seq, CORBA::ULong offset, CORBA::ULong length ) = 0;

  public:
    CORBA::ValueDef_ptr get_value_def ();
    virtual void * _narrow_helper (const char *);
    void _get_marshal_info (vector<string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    DataInputStream ();
    virtual ~DataInputStream ();

  private:
    DataInputStream (const DataInputStream &);
    void operator= (const DataInputStream &);
};

extern CORBA::TypeCodeConst _tc_DataInputStream;





}
# 314 "../include/mico/valuetype.h"
namespace OBV_CORBA {
# 324 "../include/mico/valuetype.h"
}






void operator<<=( CORBA::Any &a, const CORBA::StringValue* vb );
void operator<<=( CORBA::Any &a, CORBA::StringValue** vb_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::StringValue* & vb_ptr );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_StringValue;

void operator<<=( CORBA::Any &a, const CORBA::WStringValue* vb );
void operator<<=( CORBA::Any &a, CORBA::WStringValue** vb_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::WStringValue* & vb_ptr );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_WStringValue;

void operator<<=( CORBA::Any &a, const CORBA::CustomMarshal* val );
void operator<<=( CORBA::Any &a, CORBA::CustomMarshal** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::CustomMarshal* & val_ptr );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_CustomMarshal;

void operator<<=( CORBA::Any &a, const CORBA::DataOutputStream* val );
void operator<<=( CORBA::Any &a, CORBA::DataOutputStream** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::DataOutputStream* & val_ptr );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_DataOutputStream;

void operator<<=( CORBA::Any &a, const CORBA::DataInputStream* val );
void operator<<=( CORBA::Any &a, CORBA::DataInputStream** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::DataInputStream* & val_ptr );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_DataInputStream;





# 1 "../include/mico/template_impl.h" 1
# 366 "../include/mico/valuetype.h" 2
# 220 "../include/CORBA.h" 2


# 1 "../include/mico/ir.h" 1







# 1 "../include/CORBA.h" 1
# 9 "../include/mico/ir.h" 2





namespace CORBA {


typedef char* ScopedName;
typedef CORBA::String_var ScopedName_var;
typedef CORBA::String_out ScopedName_out;

extern CORBA::TypeCodeConst _tc_ScopedName;

class Container;
typedef Container *Container_ptr;
typedef Container_ptr ContainerRef;
typedef ObjVar<Container> Container_var;
typedef ObjOut<Container> Container_out;

class Repository;
typedef Repository *Repository_ptr;
typedef Repository_ptr RepositoryRef;
typedef ObjVar<Repository> Repository_var;
typedef ObjOut<Repository> Repository_out;

class Contained;
typedef Contained *Contained_ptr;
typedef Contained_ptr ContainedRef;
typedef ObjVar<Contained> Contained_var;
typedef ObjOut<Contained> Contained_out;



class Contained :
  virtual public ::CORBA::IRObject
{
  public:
    typedef ::CORBA::IRObject _VCHACK__CORBA__IRObject;
    virtual ~Contained();


    typedef Contained_ptr _ptr_type;
    typedef Contained_var _var_type;


    static Contained_ptr _narrow( CORBA::Object_ptr obj );
    static Contained_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Contained_ptr _duplicate( Contained_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Contained_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct Description;
    typedef TVarVar<Description> Description_var;
    typedef TVarOut<Description> Description_out;

    struct Description {

      typedef Description_var _var_type;
# 85 "../include/mico/ir.h"
      DefinitionKind kind;
      CORBA::Any value;
    };

    static CORBA::TypeCodeConst _tc_Description;

    virtual char* id() = 0;
    virtual void id( const char* value ) = 0;
    virtual char* name() = 0;
    virtual void name( const char* value ) = 0;
    virtual char* version() = 0;
    virtual void version( const char* value ) = 0;
    virtual Container_ptr defined_in() = 0;
    virtual char* absolute_name() = 0;
    virtual Repository_ptr containing_repository() = 0;

    virtual Description* describe() = 0;
    virtual void move( Container_ptr new_container, const char* new_name, const char* new_version ) = 0;

  protected:
    Contained() {};
  private:
    Contained( const Contained& );
    void operator=( const Contained& );
};

extern CORBA::TypeCodeConst _tc_Contained;


class Contained_stub:
  virtual public Contained,
  virtual public ::CORBA::IRObject_stub
{
  public:
    virtual ~Contained_stub();
    char* id();
    void id( const char* value );
    char* name();
    void name( const char* value );
    char* version();
    void version( const char* value );
    Container_ptr defined_in();
    char* absolute_name();
    Repository_ptr containing_repository();

    Description* describe();
    void move( Container_ptr new_container, const char* new_name, const char* new_version );

  private:
    void operator=( const Contained_stub& );
};



class Contained_stub_clp :
  virtual public Contained_stub,
  virtual public ::CORBA::IRObject_stub_clp
{
  public:
    Contained_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Contained_stub_clp ();
    char* id();
    void id( const char* value );
    char* name();
    void name( const char* value );
    char* version();
    void version( const char* value );
    Container_ptr defined_in();
    char* absolute_name();
    Repository_ptr containing_repository();

    Description* describe();
    void move( Container_ptr new_container, const char* new_name, const char* new_version );

  protected:
    Contained_stub_clp ();
  private:
    void operator=( const Contained_stub_clp & );
};



typedef IfaceSequenceTmpl<Contained_var,Contained_ptr> ContainedSeq;



typedef TSeqVar<IfaceSequenceTmpl<Contained_var,Contained_ptr> > ContainedSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<Contained_var,Contained_ptr> > ContainedSeq_out;

extern CORBA::TypeCodeConst _tc_ContainedSeq;

class ModuleDef;
typedef ModuleDef *ModuleDef_ptr;
typedef ModuleDef_ptr ModuleDefRef;
typedef ObjVar<ModuleDef> ModuleDef_var;
typedef ObjOut<ModuleDef> ModuleDef_out;

class ConstantDef;
typedef ConstantDef *ConstantDef_ptr;
typedef ConstantDef_ptr ConstantDefRef;
typedef ObjVar<ConstantDef> ConstantDef_var;
typedef ObjOut<ConstantDef> ConstantDef_out;

class StructDef;
typedef StructDef *StructDef_ptr;
typedef StructDef_ptr StructDefRef;
typedef ObjVar<StructDef> StructDef_var;
typedef ObjOut<StructDef> StructDef_out;

class ExceptionDef;
typedef ExceptionDef *ExceptionDef_ptr;
typedef ExceptionDef_ptr ExceptionDefRef;
typedef ObjVar<ExceptionDef> ExceptionDef_var;
typedef ObjOut<ExceptionDef> ExceptionDef_out;

class UnionDef;
typedef UnionDef *UnionDef_ptr;
typedef UnionDef_ptr UnionDefRef;
typedef ObjVar<UnionDef> UnionDef_var;
typedef ObjOut<UnionDef> UnionDef_out;

class EnumDef;
typedef EnumDef *EnumDef_ptr;
typedef EnumDef_ptr EnumDefRef;
typedef ObjVar<EnumDef> EnumDef_var;
typedef ObjOut<EnumDef> EnumDef_out;

class AliasDef;
typedef AliasDef *AliasDef_ptr;
typedef AliasDef_ptr AliasDefRef;
typedef ObjVar<AliasDef> AliasDef_var;
typedef ObjOut<AliasDef> AliasDef_out;

class InterfaceDef;

typedef InterfaceDef_ptr InterfaceDefRef;
typedef ObjVar<InterfaceDef> InterfaceDef_var;
typedef ObjOut<InterfaceDef> InterfaceDef_out;

typedef IfaceSequenceTmpl<InterfaceDef_var,InterfaceDef_ptr> InterfaceDefSeq;



typedef TSeqVar<IfaceSequenceTmpl<InterfaceDef_var,InterfaceDef_ptr> > InterfaceDefSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<InterfaceDef_var,InterfaceDef_ptr> > InterfaceDefSeq_out;

extern CORBA::TypeCodeConst _tc_InterfaceDefSeq;

class AbstractInterfaceDef;
typedef AbstractInterfaceDef *AbstractInterfaceDef_ptr;
typedef AbstractInterfaceDef_ptr AbstractInterfaceDefRef;
typedef ObjVar<AbstractInterfaceDef> AbstractInterfaceDef_var;
typedef ObjOut<AbstractInterfaceDef> AbstractInterfaceDef_out;

typedef IfaceSequenceTmpl<AbstractInterfaceDef_var,AbstractInterfaceDef_ptr> AbstractInterfaceDefSeq;



typedef TSeqVar<IfaceSequenceTmpl<AbstractInterfaceDef_var,AbstractInterfaceDef_ptr> > AbstractInterfaceDefSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<AbstractInterfaceDef_var,AbstractInterfaceDef_ptr> > AbstractInterfaceDefSeq_out;

extern CORBA::TypeCodeConst _tc_AbstractInterfaceDefSeq;

class LocalInterfaceDef;
typedef LocalInterfaceDef *LocalInterfaceDef_ptr;
typedef LocalInterfaceDef_ptr LocalInterfaceDefRef;
typedef ObjVar<LocalInterfaceDef> LocalInterfaceDef_var;
typedef ObjOut<LocalInterfaceDef> LocalInterfaceDef_out;

typedef IfaceSequenceTmpl<LocalInterfaceDef_var,LocalInterfaceDef_ptr> LocalInterfaceDefSeq;



typedef TSeqVar<IfaceSequenceTmpl<LocalInterfaceDef_var,LocalInterfaceDef_ptr> > LocalInterfaceDefSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<LocalInterfaceDef_var,LocalInterfaceDef_ptr> > LocalInterfaceDefSeq_out;

extern CORBA::TypeCodeConst _tc_LocalInterfaceDefSeq;

class ValueDef;

typedef ValueDef_ptr ValueDefRef;
typedef ObjVar<ValueDef> ValueDef_var;
typedef ObjOut<ValueDef> ValueDef_out;

typedef IfaceSequenceTmpl<ValueDef_var,ValueDef_ptr> ValueDefSeq;



typedef TSeqVar<IfaceSequenceTmpl<ValueDef_var,ValueDef_ptr> > ValueDefSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<ValueDef_var,ValueDef_ptr> > ValueDefSeq_out;

extern CORBA::TypeCodeConst _tc_ValueDefSeq;

struct Initializer;
typedef TVarVar<Initializer> Initializer_var;
typedef TVarOut<Initializer> Initializer_out;

struct Initializer {

  typedef Initializer_var _var_type;
# 293 "../include/mico/ir.h"
  StructMemberSeq members;
  Identifier_var name;
};

extern CORBA::TypeCodeConst _tc_Initializer;

typedef SequenceTmpl<Initializer,0> InitializerSeq;



typedef TSeqVar<SequenceTmpl<Initializer,0> > InitializerSeq_var;
typedef TSeqOut<SequenceTmpl<Initializer,0> > InitializerSeq_out;

extern CORBA::TypeCodeConst _tc_InitializerSeq;

class ValueBoxDef;
typedef ValueBoxDef *ValueBoxDef_ptr;
typedef ValueBoxDef_ptr ValueBoxDefRef;
typedef ObjVar<ValueBoxDef> ValueBoxDef_var;
typedef ObjOut<ValueBoxDef> ValueBoxDef_out;

class NativeDef;
typedef NativeDef *NativeDef_ptr;
typedef NativeDef_ptr NativeDefRef;
typedef ObjVar<NativeDef> NativeDef_var;
typedef ObjOut<NativeDef> NativeDef_out;



class Container :
  virtual public ::CORBA::IRObject
{
  public:
    typedef ::CORBA::IRObject _VCHACK__CORBA__IRObject;
    virtual ~Container();


    typedef Container_ptr _ptr_type;
    typedef Container_var _var_type;


    static Container_ptr _narrow( CORBA::Object_ptr obj );
    static Container_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Container_ptr _duplicate( Container_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Container_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct Description;
    typedef TVarVar<Description> Description_var;
    typedef TVarOut<Description> Description_out;

    struct Description {

      typedef Description_var _var_type;
# 364 "../include/mico/ir.h"
      Contained_var contained_object;
      DefinitionKind kind;
      CORBA::Any value;
    };

    static CORBA::TypeCodeConst _tc_Description;

    typedef SequenceTmpl<Description,0> DescriptionSeq;



    typedef TSeqVar<SequenceTmpl<Description,0> > DescriptionSeq_var;
    typedef TSeqOut<SequenceTmpl<Description,0> > DescriptionSeq_out;

    static CORBA::TypeCodeConst _tc_DescriptionSeq;

    virtual Contained_ptr lookup( const char* search_name ) = 0;
    virtual ContainedSeq* contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited ) = 0;
    virtual ContainedSeq* lookup_name( const char* search_name, CORBA::Long levels_to_search, DefinitionKind limit_type, CORBA::Boolean exclude_inherited ) = 0;
    virtual DescriptionSeq* describe_contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited, CORBA::Long max_returned_objs ) = 0;
    virtual ModuleDef_ptr create_module( const char* id, const char* name, const char* version ) = 0;
    virtual ConstantDef_ptr create_constant( const char* id, const char* name, const char* version, IDLType_ptr type, const CORBA::Any& value ) = 0;
    virtual StructDef_ptr create_struct( const char* id, const char* name, const char* version, const StructMemberSeq& members ) = 0;
    virtual ExceptionDef_ptr create_exception( const char* id, const char* name, const char* version, const StructMemberSeq& members ) = 0;
    virtual UnionDef_ptr create_union( const char* id, const char* name, const char* version, IDLType_ptr discriminator_type, const UnionMemberSeq& members ) = 0;
    virtual EnumDef_ptr create_enum( const char* id, const char* name, const char* version, const EnumMemberSeq& members ) = 0;
    virtual AliasDef_ptr create_alias( const char* id, const char* name, const char* version, IDLType_ptr original_type ) = 0;
    virtual InterfaceDef_ptr create_interface( const char* id, const char* name, const char* version, const InterfaceDefSeq& base_interfaces ) = 0;
    virtual AbstractInterfaceDef_ptr create_abstract_interface( const char* id, const char* name, const char* version, const AbstractInterfaceDefSeq& base_interfaces ) = 0;
    virtual LocalInterfaceDef_ptr create_local_interface( const char* id, const char* name, const char* version, const LocalInterfaceDefSeq& base_interfaces ) = 0;
    virtual ValueDef_ptr create_value( const char* id, const char* name, const char* version, CORBA::Boolean is_custom, CORBA::Boolean is_abstract, ValueDef_ptr base_value, CORBA::Boolean is_truncatable, const ValueDefSeq& abstract_base_values, const InterfaceDefSeq& supported_interfaces, const InitializerSeq& initializers ) = 0;
    virtual ValueBoxDef_ptr create_value_box( const char* id, const char* name, const char* version, IDLType_ptr original_type_def ) = 0;
    virtual NativeDef_ptr create_native( const char* id, const char* name, const char* version ) = 0;

  protected:
    Container() {};
  private:
    Container( const Container& );
    void operator=( const Container& );
};

extern CORBA::TypeCodeConst _tc_Container;


class Container_stub:
  virtual public Container,
  virtual public ::CORBA::IRObject_stub
{
  public:
    virtual ~Container_stub();
    Contained_ptr lookup( const char* search_name );
    ContainedSeq* contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited );
    ContainedSeq* lookup_name( const char* search_name, CORBA::Long levels_to_search, DefinitionKind limit_type, CORBA::Boolean exclude_inherited );
    DescriptionSeq* describe_contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited, CORBA::Long max_returned_objs );
    ModuleDef_ptr create_module( const char* id, const char* name, const char* version );
    ConstantDef_ptr create_constant( const char* id, const char* name, const char* version, IDLType_ptr type, const CORBA::Any& value );
    StructDef_ptr create_struct( const char* id, const char* name, const char* version, const StructMemberSeq& members );
    ExceptionDef_ptr create_exception( const char* id, const char* name, const char* version, const StructMemberSeq& members );
    UnionDef_ptr create_union( const char* id, const char* name, const char* version, IDLType_ptr discriminator_type, const UnionMemberSeq& members );
    EnumDef_ptr create_enum( const char* id, const char* name, const char* version, const EnumMemberSeq& members );
    AliasDef_ptr create_alias( const char* id, const char* name, const char* version, IDLType_ptr original_type );
    InterfaceDef_ptr create_interface( const char* id, const char* name, const char* version, const InterfaceDefSeq& base_interfaces );
    AbstractInterfaceDef_ptr create_abstract_interface( const char* id, const char* name, const char* version, const AbstractInterfaceDefSeq& base_interfaces );
    LocalInterfaceDef_ptr create_local_interface( const char* id, const char* name, const char* version, const LocalInterfaceDefSeq& base_interfaces );
    ValueDef_ptr create_value( const char* id, const char* name, const char* version, CORBA::Boolean is_custom, CORBA::Boolean is_abstract, ValueDef_ptr base_value, CORBA::Boolean is_truncatable, const ValueDefSeq& abstract_base_values, const InterfaceDefSeq& supported_interfaces, const InitializerSeq& initializers );
    ValueBoxDef_ptr create_value_box( const char* id, const char* name, const char* version, IDLType_ptr original_type_def );
    NativeDef_ptr create_native( const char* id, const char* name, const char* version );

  private:
    void operator=( const Container_stub& );
};



class Container_stub_clp :
  virtual public Container_stub,
  virtual public ::CORBA::IRObject_stub_clp
{
  public:
    Container_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Container_stub_clp ();
    Contained_ptr lookup( const char* search_name );
    ContainedSeq* contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited );
    ContainedSeq* lookup_name( const char* search_name, CORBA::Long levels_to_search, DefinitionKind limit_type, CORBA::Boolean exclude_inherited );
    DescriptionSeq* describe_contents( DefinitionKind limit_type, CORBA::Boolean exclude_inherited, CORBA::Long max_returned_objs );
    ModuleDef_ptr create_module( const char* id, const char* name, const char* version );
    ConstantDef_ptr create_constant( const char* id, const char* name, const char* version, IDLType_ptr type, const CORBA::Any& value );
    StructDef_ptr create_struct( const char* id, const char* name, const char* version, const StructMemberSeq& members );
    ExceptionDef_ptr create_exception( const char* id, const char* name, const char* version, const StructMemberSeq& members );
    UnionDef_ptr create_union( const char* id, const char* name, const char* version, IDLType_ptr discriminator_type, const UnionMemberSeq& members );
    EnumDef_ptr create_enum( const char* id, const char* name, const char* version, const EnumMemberSeq& members );
    AliasDef_ptr create_alias( const char* id, const char* name, const char* version, IDLType_ptr original_type );
    InterfaceDef_ptr create_interface( const char* id, const char* name, const char* version, const InterfaceDefSeq& base_interfaces );
    AbstractInterfaceDef_ptr create_abstract_interface( const char* id, const char* name, const char* version, const AbstractInterfaceDefSeq& base_interfaces );
    LocalInterfaceDef_ptr create_local_interface( const char* id, const char* name, const char* version, const LocalInterfaceDefSeq& base_interfaces );
    ValueDef_ptr create_value( const char* id, const char* name, const char* version, CORBA::Boolean is_custom, CORBA::Boolean is_abstract, ValueDef_ptr base_value, CORBA::Boolean is_truncatable, const ValueDefSeq& abstract_base_values, const InterfaceDefSeq& supported_interfaces, const InitializerSeq& initializers );
    ValueBoxDef_ptr create_value_box( const char* id, const char* name, const char* version, IDLType_ptr original_type_def );
    NativeDef_ptr create_native( const char* id, const char* name, const char* version );

  protected:
    Container_stub_clp ();
  private:
    void operator=( const Container_stub_clp & );
};



class PrimitiveDef;
typedef PrimitiveDef *PrimitiveDef_ptr;
typedef PrimitiveDef_ptr PrimitiveDefRef;
typedef ObjVar<PrimitiveDef> PrimitiveDef_var;
typedef ObjOut<PrimitiveDef> PrimitiveDef_out;

enum PrimitiveKind {
  pk_null = 0,
  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
};

typedef PrimitiveKind& PrimitiveKind_out;

extern CORBA::TypeCodeConst _tc_PrimitiveKind;

class StringDef;
typedef StringDef *StringDef_ptr;
typedef StringDef_ptr StringDefRef;
typedef ObjVar<StringDef> StringDef_var;
typedef ObjOut<StringDef> StringDef_out;

class WstringDef;
typedef WstringDef *WstringDef_ptr;
typedef WstringDef_ptr WstringDefRef;
typedef ObjVar<WstringDef> WstringDef_var;
typedef ObjOut<WstringDef> WstringDef_out;

class SequenceDef;
typedef SequenceDef *SequenceDef_ptr;
typedef SequenceDef_ptr SequenceDefRef;
typedef ObjVar<SequenceDef> SequenceDef_var;
typedef ObjOut<SequenceDef> SequenceDef_out;

class ArrayDef;
typedef ArrayDef *ArrayDef_ptr;
typedef ArrayDef_ptr ArrayDefRef;
typedef ObjVar<ArrayDef> ArrayDef_var;
typedef ObjOut<ArrayDef> ArrayDef_out;

class FixedDef;
typedef FixedDef *FixedDef_ptr;
typedef FixedDef_ptr FixedDefRef;
typedef ObjVar<FixedDef> FixedDef_var;
typedef ObjOut<FixedDef> FixedDef_out;



class Repository :
  virtual public ::CORBA::Container
{
  public:
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    virtual ~Repository();


    typedef Repository_ptr _ptr_type;
    typedef Repository_var _var_type;


    static Repository_ptr _narrow( CORBA::Object_ptr obj );
    static Repository_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Repository_ptr _duplicate( Repository_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Repository_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Contained_ptr lookup_id( const char* search_id ) = 0;
    virtual PrimitiveDef_ptr get_primitive( PrimitiveKind kind ) = 0;
    virtual StringDef_ptr create_string( CORBA::ULong bound ) = 0;
    virtual WstringDef_ptr create_wstring( CORBA::ULong bound ) = 0;
    virtual SequenceDef_ptr create_sequence( CORBA::ULong bound, IDLType_ptr element_type ) = 0;
    virtual ArrayDef_ptr create_array( CORBA::ULong length, IDLType_ptr element_type ) = 0;
    virtual FixedDef_ptr create_fixed( CORBA::UShort digits, CORBA::Short scale ) = 0;

  protected:
    Repository() {};
  private:
    Repository( const Repository& );
    void operator=( const Repository& );
};

extern CORBA::TypeCodeConst _tc_Repository;


class Repository_stub:
  virtual public Repository,
  virtual public ::CORBA::Container_stub
{
  public:
    virtual ~Repository_stub();
    Contained_ptr lookup_id( const char* search_id );
    PrimitiveDef_ptr get_primitive( PrimitiveKind kind );
    StringDef_ptr create_string( CORBA::ULong bound );
    WstringDef_ptr create_wstring( CORBA::ULong bound );
    SequenceDef_ptr create_sequence( CORBA::ULong bound, IDLType_ptr element_type );
    ArrayDef_ptr create_array( CORBA::ULong length, IDLType_ptr element_type );
    FixedDef_ptr create_fixed( CORBA::UShort digits, CORBA::Short scale );

  private:
    void operator=( const Repository_stub& );
};



class Repository_stub_clp :
  virtual public Repository_stub,
  virtual public ::CORBA::Container_stub_clp
{
  public:
    Repository_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Repository_stub_clp ();
    Contained_ptr lookup_id( const char* search_id );
    PrimitiveDef_ptr get_primitive( PrimitiveKind kind );
    StringDef_ptr create_string( CORBA::ULong bound );
    WstringDef_ptr create_wstring( CORBA::ULong bound );
    SequenceDef_ptr create_sequence( CORBA::ULong bound, IDLType_ptr element_type );
    ArrayDef_ptr create_array( CORBA::ULong length, IDLType_ptr element_type );
    FixedDef_ptr create_fixed( CORBA::UShort digits, CORBA::Short scale );

  protected:
    Repository_stub_clp ();
  private:
    void operator=( const Repository_stub_clp & );
};





class ModuleDef :
  virtual public ::CORBA::Container,
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~ModuleDef();


    typedef ModuleDef_ptr _ptr_type;
    typedef ModuleDef_var _var_type;


    static ModuleDef_ptr _narrow( CORBA::Object_ptr obj );
    static ModuleDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ModuleDef_ptr _duplicate( ModuleDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ModuleDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    ModuleDef() {};
  private:
    ModuleDef( const ModuleDef& );
    void operator=( const ModuleDef& );
};

extern CORBA::TypeCodeConst _tc_ModuleDef;


class ModuleDef_stub:
  virtual public ModuleDef,
  virtual public ::CORBA::Container_stub,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~ModuleDef_stub();
  private:
    void operator=( const ModuleDef_stub& );
};



class ModuleDef_stub_clp :
  virtual public ModuleDef_stub,
  virtual public ::CORBA::Container_stub_clp,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    ModuleDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ModuleDef_stub_clp ();
  protected:
    ModuleDef_stub_clp ();
  private:
    void operator=( const ModuleDef_stub_clp & );
};





class ConstantDef :
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~ConstantDef();


    typedef ConstantDef_ptr _ptr_type;
    typedef ConstantDef_var _var_type;


    static ConstantDef_ptr _narrow( CORBA::Object_ptr obj );
    static ConstantDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ConstantDef_ptr _duplicate( ConstantDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ConstantDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual IDLType_ptr type_def() = 0;
    virtual void type_def( IDLType_ptr value ) = 0;
    virtual CORBA::Any* value() = 0;
    virtual void value( const CORBA::Any& value ) = 0;

  protected:
    ConstantDef() {};
  private:
    ConstantDef( const ConstantDef& );
    void operator=( const ConstantDef& );
};

extern CORBA::TypeCodeConst _tc_ConstantDef;


class ConstantDef_stub:
  virtual public ConstantDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~ConstantDef_stub();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    CORBA::Any* value();
    void value( const CORBA::Any& value );

  private:
    void operator=( const ConstantDef_stub& );
};



class ConstantDef_stub_clp :
  virtual public ConstantDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    ConstantDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ConstantDef_stub_clp ();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    CORBA::Any* value();
    void value( const CORBA::Any& value );

  protected:
    ConstantDef_stub_clp ();
  private:
    void operator=( const ConstantDef_stub_clp & );
};



class TypedefDef;
typedef TypedefDef *TypedefDef_ptr;
typedef TypedefDef_ptr TypedefDefRef;
typedef ObjVar<TypedefDef> TypedefDef_var;
typedef ObjOut<TypedefDef> TypedefDef_out;



class TypedefDef :
  virtual public ::CORBA::Contained,
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~TypedefDef();


    typedef TypedefDef_ptr _ptr_type;
    typedef TypedefDef_var _var_type;


    static TypedefDef_ptr _narrow( CORBA::Object_ptr obj );
    static TypedefDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static TypedefDef_ptr _duplicate( TypedefDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static TypedefDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    TypedefDef() {};
  private:
    TypedefDef( const TypedefDef& );
    void operator=( const TypedefDef& );
};

extern CORBA::TypeCodeConst _tc_TypedefDef;


class TypedefDef_stub:
  virtual public TypedefDef,
  virtual public ::CORBA::Contained_stub,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~TypedefDef_stub();
  private:
    void operator=( const TypedefDef_stub& );
};



class TypedefDef_stub_clp :
  virtual public TypedefDef_stub,
  virtual public ::CORBA::Contained_stub_clp,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    TypedefDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~TypedefDef_stub_clp ();
  protected:
    TypedefDef_stub_clp ();
  private:
    void operator=( const TypedefDef_stub_clp & );
};





class StructDef :
  virtual public ::CORBA::TypedefDef,
  virtual public ::CORBA::Container
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    virtual ~StructDef();


    typedef StructDef_ptr _ptr_type;
    typedef StructDef_var _var_type;


    static StructDef_ptr _narrow( CORBA::Object_ptr obj );
    static StructDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static StructDef_ptr _duplicate( StructDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static StructDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual StructMemberSeq* members() = 0;
    virtual void members( const StructMemberSeq& value ) = 0;

  protected:
    StructDef() {};
  private:
    StructDef( const StructDef& );
    void operator=( const StructDef& );
};

extern CORBA::TypeCodeConst _tc_StructDef;


class StructDef_stub:
  virtual public StructDef,
  virtual public ::CORBA::TypedefDef_stub,
  virtual public ::CORBA::Container_stub
{
  public:
    virtual ~StructDef_stub();
    StructMemberSeq* members();
    void members( const StructMemberSeq& value );

  private:
    void operator=( const StructDef_stub& );
};



class StructDef_stub_clp :
  virtual public StructDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp,
  virtual public ::CORBA::Container_stub_clp
{
  public:
    StructDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~StructDef_stub_clp ();
    StructMemberSeq* members();
    void members( const StructMemberSeq& value );

  protected:
    StructDef_stub_clp ();
  private:
    void operator=( const StructDef_stub_clp & );
};





class ExceptionDef :
  virtual public ::CORBA::Contained,
  virtual public ::CORBA::Container
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    virtual ~ExceptionDef();


    typedef ExceptionDef_ptr _ptr_type;
    typedef ExceptionDef_var _var_type;


    static ExceptionDef_ptr _narrow( CORBA::Object_ptr obj );
    static ExceptionDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ExceptionDef_ptr _duplicate( ExceptionDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ExceptionDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual StructMemberSeq* members() = 0;
    virtual void members( const StructMemberSeq& value ) = 0;

  protected:
    ExceptionDef() {};
  private:
    ExceptionDef( const ExceptionDef& );
    void operator=( const ExceptionDef& );
};

extern CORBA::TypeCodeConst _tc_ExceptionDef;


class ExceptionDef_stub:
  virtual public ExceptionDef,
  virtual public ::CORBA::Contained_stub,
  virtual public ::CORBA::Container_stub
{
  public:
    virtual ~ExceptionDef_stub();
    CORBA::TypeCode_ptr type();
    StructMemberSeq* members();
    void members( const StructMemberSeq& value );

  private:
    void operator=( const ExceptionDef_stub& );
};



class ExceptionDef_stub_clp :
  virtual public ExceptionDef_stub,
  virtual public ::CORBA::Contained_stub_clp,
  virtual public ::CORBA::Container_stub_clp
{
  public:
    ExceptionDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ExceptionDef_stub_clp ();
    CORBA::TypeCode_ptr type();
    StructMemberSeq* members();
    void members( const StructMemberSeq& value );

  protected:
    ExceptionDef_stub_clp ();
  private:
    void operator=( const ExceptionDef_stub_clp & );
};





class UnionDef :
  virtual public ::CORBA::TypedefDef,
  virtual public ::CORBA::Container
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    virtual ~UnionDef();


    typedef UnionDef_ptr _ptr_type;
    typedef UnionDef_var _var_type;


    static UnionDef_ptr _narrow( CORBA::Object_ptr obj );
    static UnionDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static UnionDef_ptr _duplicate( UnionDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static UnionDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr discriminator_type() = 0;
    virtual IDLType_ptr discriminator_type_def() = 0;
    virtual void discriminator_type_def( IDLType_ptr value ) = 0;
    virtual UnionMemberSeq* members() = 0;
    virtual void members( const UnionMemberSeq& value ) = 0;

  protected:
    UnionDef() {};
  private:
    UnionDef( const UnionDef& );
    void operator=( const UnionDef& );
};

extern CORBA::TypeCodeConst _tc_UnionDef;


class UnionDef_stub:
  virtual public UnionDef,
  virtual public ::CORBA::TypedefDef_stub,
  virtual public ::CORBA::Container_stub
{
  public:
    virtual ~UnionDef_stub();
    CORBA::TypeCode_ptr discriminator_type();
    IDLType_ptr discriminator_type_def();
    void discriminator_type_def( IDLType_ptr value );
    UnionMemberSeq* members();
    void members( const UnionMemberSeq& value );

  private:
    void operator=( const UnionDef_stub& );
};



class UnionDef_stub_clp :
  virtual public UnionDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp,
  virtual public ::CORBA::Container_stub_clp
{
  public:
    UnionDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~UnionDef_stub_clp ();
    CORBA::TypeCode_ptr discriminator_type();
    IDLType_ptr discriminator_type_def();
    void discriminator_type_def( IDLType_ptr value );
    UnionMemberSeq* members();
    void members( const UnionMemberSeq& value );

  protected:
    UnionDef_stub_clp ();
  private:
    void operator=( const UnionDef_stub_clp & );
};





class EnumDef :
  virtual public ::CORBA::TypedefDef
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    virtual ~EnumDef();


    typedef EnumDef_ptr _ptr_type;
    typedef EnumDef_var _var_type;


    static EnumDef_ptr _narrow( CORBA::Object_ptr obj );
    static EnumDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static EnumDef_ptr _duplicate( EnumDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static EnumDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual EnumMemberSeq* members() = 0;
    virtual void members( const EnumMemberSeq& value ) = 0;

  protected:
    EnumDef() {};
  private:
    EnumDef( const EnumDef& );
    void operator=( const EnumDef& );
};

extern CORBA::TypeCodeConst _tc_EnumDef;


class EnumDef_stub:
  virtual public EnumDef,
  virtual public ::CORBA::TypedefDef_stub
{
  public:
    virtual ~EnumDef_stub();
    EnumMemberSeq* members();
    void members( const EnumMemberSeq& value );

  private:
    void operator=( const EnumDef_stub& );
};



class EnumDef_stub_clp :
  virtual public EnumDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp
{
  public:
    EnumDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~EnumDef_stub_clp ();
    EnumMemberSeq* members();
    void members( const EnumMemberSeq& value );

  protected:
    EnumDef_stub_clp ();
  private:
    void operator=( const EnumDef_stub_clp & );
};





class AliasDef :
  virtual public ::CORBA::TypedefDef
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    virtual ~AliasDef();


    typedef AliasDef_ptr _ptr_type;
    typedef AliasDef_var _var_type;


    static AliasDef_ptr _narrow( CORBA::Object_ptr obj );
    static AliasDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static AliasDef_ptr _duplicate( AliasDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static AliasDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual IDLType_ptr original_type_def() = 0;
    virtual void original_type_def( IDLType_ptr value ) = 0;

  protected:
    AliasDef() {};
  private:
    AliasDef( const AliasDef& );
    void operator=( const AliasDef& );
};

extern CORBA::TypeCodeConst _tc_AliasDef;


class AliasDef_stub:
  virtual public AliasDef,
  virtual public ::CORBA::TypedefDef_stub
{
  public:
    virtual ~AliasDef_stub();
    IDLType_ptr original_type_def();
    void original_type_def( IDLType_ptr value );

  private:
    void operator=( const AliasDef_stub& );
};



class AliasDef_stub_clp :
  virtual public AliasDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp
{
  public:
    AliasDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~AliasDef_stub_clp ();
    IDLType_ptr original_type_def();
    void original_type_def( IDLType_ptr value );

  protected:
    AliasDef_stub_clp ();
  private:
    void operator=( const AliasDef_stub_clp & );
};



enum OperationMode {
  OP_NORMAL = 0,
  OP_ONEWAY
};

typedef OperationMode& OperationMode_out;

extern CORBA::TypeCodeConst _tc_OperationMode;

typedef char* ContextIdentifier;
typedef CORBA::String_var ContextIdentifier_var;
typedef CORBA::String_out ContextIdentifier_out;

extern CORBA::TypeCodeConst _tc_ContextIdentifier;

typedef StringSequenceTmpl<CORBA::String_var> ContextIdSeq;



typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > ContextIdSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > ContextIdSeq_out;

extern CORBA::TypeCodeConst _tc_ContextIdSeq;

enum ParameterMode {
  PARAM_IN = 0,
  PARAM_OUT,
  PARAM_INOUT
};

typedef ParameterMode& ParameterMode_out;

extern CORBA::TypeCodeConst _tc_ParameterMode;

struct ParameterDescription;
typedef TVarVar<ParameterDescription> ParameterDescription_var;
typedef TVarOut<ParameterDescription> ParameterDescription_out;

struct ParameterDescription {

  typedef ParameterDescription_var _var_type;
# 1304 "../include/mico/ir.h"
  Identifier_var name;
  CORBA::TypeCode_var type;
  IDLType_var type_def;
  ParameterMode mode;
};

extern CORBA::TypeCodeConst _tc_ParameterDescription;

typedef SequenceTmpl<ParameterDescription,0> ParDescriptionSeq;



typedef TSeqVar<SequenceTmpl<ParameterDescription,0> > ParDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<ParameterDescription,0> > ParDescriptionSeq_out;

extern CORBA::TypeCodeConst _tc_ParDescriptionSeq;

struct ExceptionDescription;
typedef TVarVar<ExceptionDescription> ExceptionDescription_var;
typedef TVarOut<ExceptionDescription> ExceptionDescription_out;

struct ExceptionDescription {

  typedef ExceptionDescription_var _var_type;
# 1336 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var type;
};

extern CORBA::TypeCodeConst _tc_ExceptionDescription;

typedef SequenceTmpl<ExceptionDescription,0> ExcDescriptionSeq;



typedef TSeqVar<SequenceTmpl<ExceptionDescription,0> > ExcDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<ExceptionDescription,0> > ExcDescriptionSeq_out;

extern CORBA::TypeCodeConst _tc_ExcDescriptionSeq;

struct OperationDescription;
typedef TVarVar<OperationDescription> OperationDescription_var;
typedef TVarOut<OperationDescription> OperationDescription_out;

struct OperationDescription {

  typedef OperationDescription_var _var_type;
# 1369 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var result;
  OperationMode mode;
  ContextIdSeq contexts;
  ParDescriptionSeq parameters;
  ExcDescriptionSeq exceptions;
};

extern CORBA::TypeCodeConst _tc_OperationDescription;

typedef SequenceTmpl<OperationDescription,0> OpDescriptionSeq;



typedef TSeqVar<SequenceTmpl<OperationDescription,0> > OpDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<OperationDescription,0> > OpDescriptionSeq_out;

extern CORBA::TypeCodeConst _tc_OpDescriptionSeq;

enum AttributeMode {
  ATTR_NORMAL = 0,
  ATTR_READONLY
};

typedef AttributeMode& AttributeMode_out;

extern CORBA::TypeCodeConst _tc_AttributeMode;

struct AttributeDescription;
typedef TVarVar<AttributeDescription> AttributeDescription_var;
typedef TVarOut<AttributeDescription> AttributeDescription_out;

struct AttributeDescription {

  typedef AttributeDescription_var _var_type;
# 1415 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var type;
  AttributeMode mode;
};

extern CORBA::TypeCodeConst _tc_AttributeDescription;

typedef SequenceTmpl<AttributeDescription,0> AttrDescriptionSeq;



typedef TSeqVar<SequenceTmpl<AttributeDescription,0> > AttrDescriptionSeq_var;
typedef TSeqOut<SequenceTmpl<AttributeDescription,0> > AttrDescriptionSeq_out;

extern CORBA::TypeCodeConst _tc_AttrDescriptionSeq;

typedef StringSequenceTmpl<CORBA::String_var> RepositoryIdSeq;



typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > RepositoryIdSeq_var;
typedef TSeqOut<StringSequenceTmpl<CORBA::String_var> > RepositoryIdSeq_out;

extern CORBA::TypeCodeConst _tc_RepositoryIdSeq;

class AttributeDef;
typedef AttributeDef *AttributeDef_ptr;
typedef AttributeDef_ptr AttributeDefRef;
typedef ObjVar<AttributeDef> AttributeDef_var;
typedef ObjOut<AttributeDef> AttributeDef_out;

class OperationDef;

typedef OperationDef_ptr OperationDefRef;
typedef ObjVar<OperationDef> OperationDef_var;
typedef ObjOut<OperationDef> OperationDef_out;

typedef IfaceSequenceTmpl<ExceptionDef_var,ExceptionDef_ptr> ExceptionDefSeq;



typedef TSeqVar<IfaceSequenceTmpl<ExceptionDef_var,ExceptionDef_ptr> > ExceptionDefSeq_var;
typedef TSeqOut<IfaceSequenceTmpl<ExceptionDef_var,ExceptionDef_ptr> > ExceptionDefSeq_out;

extern CORBA::TypeCodeConst _tc_ExceptionDefSeq;



class InterfaceDef :
  virtual public ::CORBA::Container,
  virtual public ::CORBA::Contained,
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~InterfaceDef();


    typedef InterfaceDef_ptr _ptr_type;
    typedef InterfaceDef_var _var_type;


    static InterfaceDef_ptr _narrow( CORBA::Object_ptr obj );
    static InterfaceDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static InterfaceDef_ptr _duplicate( InterfaceDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static InterfaceDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct FullInterfaceDescription;
    typedef TVarVar<FullInterfaceDescription> FullInterfaceDescription_var;
    typedef TVarOut<FullInterfaceDescription> FullInterfaceDescription_out;

    struct FullInterfaceDescription {

      typedef FullInterfaceDescription_var _var_type;
# 1512 "../include/mico/ir.h"
      Identifier_var name;
      RepositoryId_var id;
      RepositoryId_var defined_in;
      VersionSpec_var version;
      OpDescriptionSeq operations;
      AttrDescriptionSeq attributes;
      RepositoryIdSeq base_interfaces;
      CORBA::TypeCode_var type;
    };

    static CORBA::TypeCodeConst _tc_FullInterfaceDescription;

    virtual InterfaceDefSeq* base_interfaces() = 0;
    virtual void base_interfaces( const InterfaceDefSeq& value ) = 0;

    virtual CORBA::Boolean is_a( const char* interface_id ) = 0;
    virtual FullInterfaceDescription* describe_interface() = 0;
    virtual AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode ) = 0;
    virtual OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts ) = 0;

  protected:
    InterfaceDef() {};
  private:
    InterfaceDef( const InterfaceDef& );
    void operator=( const InterfaceDef& );
};

extern CORBA::TypeCodeConst _tc_InterfaceDef;


class InterfaceDef_stub:
  virtual public InterfaceDef,
  virtual public ::CORBA::Container_stub,
  virtual public ::CORBA::Contained_stub,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~InterfaceDef_stub();
    InterfaceDefSeq* base_interfaces();
    void base_interfaces( const InterfaceDefSeq& value );

    CORBA::Boolean is_a( const char* interface_id );
    FullInterfaceDescription* describe_interface();
    AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode );
    OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts );

  private:
    void operator=( const InterfaceDef_stub& );
};



class InterfaceDef_stub_clp :
  virtual public InterfaceDef_stub,
  virtual public ::CORBA::Container_stub_clp,
  virtual public ::CORBA::Contained_stub_clp,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    InterfaceDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~InterfaceDef_stub_clp ();
    InterfaceDefSeq* base_interfaces();
    void base_interfaces( const InterfaceDefSeq& value );

    CORBA::Boolean is_a( const char* interface_id );
    FullInterfaceDescription* describe_interface();
    AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode );
    OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts );

  protected:
    InterfaceDef_stub_clp ();
  private:
    void operator=( const InterfaceDef_stub_clp & );
};





class AbstractInterfaceDef :
  virtual public ::CORBA::InterfaceDef
{
  public:
    typedef ::CORBA::InterfaceDef _VCHACK__CORBA__InterfaceDef;
    virtual ~AbstractInterfaceDef();


    typedef AbstractInterfaceDef_ptr _ptr_type;
    typedef AbstractInterfaceDef_var _var_type;


    static AbstractInterfaceDef_ptr _narrow( CORBA::Object_ptr obj );
    static AbstractInterfaceDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static AbstractInterfaceDef_ptr _duplicate( AbstractInterfaceDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static AbstractInterfaceDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    AbstractInterfaceDef() {};
  private:
    AbstractInterfaceDef( const AbstractInterfaceDef& );
    void operator=( const AbstractInterfaceDef& );
};

extern CORBA::TypeCodeConst _tc_AbstractInterfaceDef;


class AbstractInterfaceDef_stub:
  virtual public AbstractInterfaceDef,
  virtual public ::CORBA::InterfaceDef_stub
{
  public:
    virtual ~AbstractInterfaceDef_stub();
  private:
    void operator=( const AbstractInterfaceDef_stub& );
};



class AbstractInterfaceDef_stub_clp :
  virtual public AbstractInterfaceDef_stub,
  virtual public ::CORBA::InterfaceDef_stub_clp
{
  public:
    AbstractInterfaceDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~AbstractInterfaceDef_stub_clp ();
  protected:
    AbstractInterfaceDef_stub_clp ();
  private:
    void operator=( const AbstractInterfaceDef_stub_clp & );
};





class LocalInterfaceDef :
  virtual public ::CORBA::InterfaceDef
{
  public:
    typedef ::CORBA::InterfaceDef _VCHACK__CORBA__InterfaceDef;
    virtual ~LocalInterfaceDef();


    typedef LocalInterfaceDef_ptr _ptr_type;
    typedef LocalInterfaceDef_var _var_type;


    static LocalInterfaceDef_ptr _narrow( CORBA::Object_ptr obj );
    static LocalInterfaceDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static LocalInterfaceDef_ptr _duplicate( LocalInterfaceDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static LocalInterfaceDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    LocalInterfaceDef() {};
  private:
    LocalInterfaceDef( const LocalInterfaceDef& );
    void operator=( const LocalInterfaceDef& );
};

extern CORBA::TypeCodeConst _tc_LocalInterfaceDef;


class LocalInterfaceDef_stub:
  virtual public LocalInterfaceDef,
  virtual public ::CORBA::InterfaceDef_stub
{
  public:
    virtual ~LocalInterfaceDef_stub();
  private:
    void operator=( const LocalInterfaceDef_stub& );
};



class LocalInterfaceDef_stub_clp :
  virtual public LocalInterfaceDef_stub,
  virtual public ::CORBA::InterfaceDef_stub_clp
{
  public:
    LocalInterfaceDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~LocalInterfaceDef_stub_clp ();
  protected:
    LocalInterfaceDef_stub_clp ();
  private:
    void operator=( const LocalInterfaceDef_stub_clp & );
};



class ValueMemberDef;
typedef ValueMemberDef *ValueMemberDef_ptr;
typedef ValueMemberDef_ptr ValueMemberDefRef;
typedef ObjVar<ValueMemberDef> ValueMemberDef_var;
typedef ObjOut<ValueMemberDef> ValueMemberDef_out;



class ValueDef :
  virtual public ::CORBA::Container,
  virtual public ::CORBA::Contained,
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::Container _VCHACK__CORBA__Container;
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~ValueDef();


    typedef ValueDef_ptr _ptr_type;
    typedef ValueDef_var _var_type;


    static ValueDef_ptr _narrow( CORBA::Object_ptr obj );
    static ValueDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ValueDef_ptr _duplicate( ValueDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ValueDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct FullValueDescription;
    typedef TVarVar<FullValueDescription> FullValueDescription_var;
    typedef TVarOut<FullValueDescription> FullValueDescription_out;

    struct FullValueDescription {

      typedef FullValueDescription_var _var_type;
# 1775 "../include/mico/ir.h"
      Identifier_var name;
      RepositoryId_var id;
      CORBA::Boolean is_abstract;
      CORBA::Boolean is_custom;
      RepositoryId_var defined_in;
      VersionSpec_var version;
      OpDescriptionSeq operations;
      AttrDescriptionSeq attributes;
      ValueMemberSeq members;
      InitializerSeq initializers;
      RepositoryIdSeq supported_interfaces;
      RepositoryIdSeq abstract_base_values;
      CORBA::Boolean is_truncatable;
      RepositoryId_var base_value;
      CORBA::TypeCode_var type;
    };

    static CORBA::TypeCodeConst _tc_FullValueDescription;

    virtual InterfaceDefSeq* supported_interfaces() = 0;
    virtual void supported_interfaces( const InterfaceDefSeq& value ) = 0;
    virtual InitializerSeq* initializers() = 0;
    virtual void initializers( const InitializerSeq& value ) = 0;
    virtual ValueDef_ptr base_value() = 0;
    virtual void base_value( ValueDef_ptr value ) = 0;
    virtual ValueDefSeq* abstract_base_values() = 0;
    virtual void abstract_base_values( const ValueDefSeq& value ) = 0;
    virtual CORBA::Boolean is_abstract() = 0;
    virtual void is_abstract( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean is_custom() = 0;
    virtual void is_custom( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean is_truncatable() = 0;
    virtual void is_truncatable( CORBA::Boolean value ) = 0;

    virtual CORBA::Boolean is_a( const char* value_id ) = 0;
    virtual FullValueDescription* describe_value() = 0;
    virtual ValueMemberDef_ptr create_value_member( const char* id, const char* name, const char* version, IDLType_ptr type, Visibility access ) = 0;
    virtual AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode ) = 0;
    virtual OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts ) = 0;

  protected:
    ValueDef() {};
  private:
    ValueDef( const ValueDef& );
    void operator=( const ValueDef& );
};

extern CORBA::TypeCodeConst _tc_ValueDef;


class ValueDef_stub:
  virtual public ValueDef,
  virtual public ::CORBA::Container_stub,
  virtual public ::CORBA::Contained_stub,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~ValueDef_stub();
    InterfaceDefSeq* supported_interfaces();
    void supported_interfaces( const InterfaceDefSeq& value );
    InitializerSeq* initializers();
    void initializers( const InitializerSeq& value );
    ValueDef_ptr base_value();
    void base_value( ValueDef_ptr value );
    ValueDefSeq* abstract_base_values();
    void abstract_base_values( const ValueDefSeq& value );
    CORBA::Boolean is_abstract();
    void is_abstract( CORBA::Boolean value );
    CORBA::Boolean is_custom();
    void is_custom( CORBA::Boolean value );
    CORBA::Boolean is_truncatable();
    void is_truncatable( CORBA::Boolean value );

    CORBA::Boolean is_a( const char* value_id );
    FullValueDescription* describe_value();
    ValueMemberDef_ptr create_value_member( const char* id, const char* name, const char* version, IDLType_ptr type, Visibility access );
    AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode );
    OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts );

  private:
    void operator=( const ValueDef_stub& );
};



class ValueDef_stub_clp :
  virtual public ValueDef_stub,
  virtual public ::CORBA::Container_stub_clp,
  virtual public ::CORBA::Contained_stub_clp,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    ValueDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ValueDef_stub_clp ();
    InterfaceDefSeq* supported_interfaces();
    void supported_interfaces( const InterfaceDefSeq& value );
    InitializerSeq* initializers();
    void initializers( const InitializerSeq& value );
    ValueDef_ptr base_value();
    void base_value( ValueDef_ptr value );
    ValueDefSeq* abstract_base_values();
    void abstract_base_values( const ValueDefSeq& value );
    CORBA::Boolean is_abstract();
    void is_abstract( CORBA::Boolean value );
    CORBA::Boolean is_custom();
    void is_custom( CORBA::Boolean value );
    CORBA::Boolean is_truncatable();
    void is_truncatable( CORBA::Boolean value );

    CORBA::Boolean is_a( const char* value_id );
    FullValueDescription* describe_value();
    ValueMemberDef_ptr create_value_member( const char* id, const char* name, const char* version, IDLType_ptr type, Visibility access );
    AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, IDLType_ptr type, AttributeMode mode );
    OperationDef_ptr create_operation( const char* id, const char* name, const char* version, IDLType_ptr result, OperationMode mode, const ParDescriptionSeq& params, const ExceptionDefSeq& exceptions, const ContextIdSeq& contexts );

  protected:
    ValueDef_stub_clp ();
  private:
    void operator=( const ValueDef_stub_clp & );
};





class ValueBoxDef :
  virtual public ::CORBA::TypedefDef
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    virtual ~ValueBoxDef();


    typedef ValueBoxDef_ptr _ptr_type;
    typedef ValueBoxDef_var _var_type;


    static ValueBoxDef_ptr _narrow( CORBA::Object_ptr obj );
    static ValueBoxDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ValueBoxDef_ptr _duplicate( ValueBoxDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ValueBoxDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual IDLType_ptr original_type_def() = 0;
    virtual void original_type_def( IDLType_ptr value ) = 0;

  protected:
    ValueBoxDef() {};
  private:
    ValueBoxDef( const ValueBoxDef& );
    void operator=( const ValueBoxDef& );
};

extern CORBA::TypeCodeConst _tc_ValueBoxDef;


class ValueBoxDef_stub:
  virtual public ValueBoxDef,
  virtual public ::CORBA::TypedefDef_stub
{
  public:
    virtual ~ValueBoxDef_stub();
    IDLType_ptr original_type_def();
    void original_type_def( IDLType_ptr value );

  private:
    void operator=( const ValueBoxDef_stub& );
};



class ValueBoxDef_stub_clp :
  virtual public ValueBoxDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp
{
  public:
    ValueBoxDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ValueBoxDef_stub_clp ();
    IDLType_ptr original_type_def();
    void original_type_def( IDLType_ptr value );

  protected:
    ValueBoxDef_stub_clp ();
  private:
    void operator=( const ValueBoxDef_stub_clp & );
};





class NativeDef :
  virtual public ::CORBA::TypedefDef
{
  public:
    typedef ::CORBA::TypedefDef _VCHACK__CORBA__TypedefDef;
    virtual ~NativeDef();


    typedef NativeDef_ptr _ptr_type;
    typedef NativeDef_var _var_type;


    static NativeDef_ptr _narrow( CORBA::Object_ptr obj );
    static NativeDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static NativeDef_ptr _duplicate( NativeDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static NativeDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    NativeDef() {};
  private:
    NativeDef( const NativeDef& );
    void operator=( const NativeDef& );
};

extern CORBA::TypeCodeConst _tc_NativeDef;


class NativeDef_stub:
  virtual public NativeDef,
  virtual public ::CORBA::TypedefDef_stub
{
  public:
    virtual ~NativeDef_stub();
  private:
    void operator=( const NativeDef_stub& );
};



class NativeDef_stub_clp :
  virtual public NativeDef_stub,
  virtual public ::CORBA::TypedefDef_stub_clp
{
  public:
    NativeDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~NativeDef_stub_clp ();
  protected:
    NativeDef_stub_clp ();
  private:
    void operator=( const NativeDef_stub_clp & );
};





class PrimitiveDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~PrimitiveDef();


    typedef PrimitiveDef_ptr _ptr_type;
    typedef PrimitiveDef_var _var_type;


    static PrimitiveDef_ptr _narrow( CORBA::Object_ptr obj );
    static PrimitiveDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static PrimitiveDef_ptr _duplicate( PrimitiveDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static PrimitiveDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual PrimitiveKind kind() = 0;

  protected:
    PrimitiveDef() {};
  private:
    PrimitiveDef( const PrimitiveDef& );
    void operator=( const PrimitiveDef& );
};

extern CORBA::TypeCodeConst _tc_PrimitiveDef;


class PrimitiveDef_stub:
  virtual public PrimitiveDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~PrimitiveDef_stub();
    PrimitiveKind kind();

  private:
    void operator=( const PrimitiveDef_stub& );
};



class PrimitiveDef_stub_clp :
  virtual public PrimitiveDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    PrimitiveDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~PrimitiveDef_stub_clp ();
    PrimitiveKind kind();

  protected:
    PrimitiveDef_stub_clp ();
  private:
    void operator=( const PrimitiveDef_stub_clp & );
};





class StringDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~StringDef();


    typedef StringDef_ptr _ptr_type;
    typedef StringDef_var _var_type;


    static StringDef_ptr _narrow( CORBA::Object_ptr obj );
    static StringDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static StringDef_ptr _duplicate( StringDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static StringDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;

  protected:
    StringDef() {};
  private:
    StringDef( const StringDef& );
    void operator=( const StringDef& );
};

extern CORBA::TypeCodeConst _tc_StringDef;


class StringDef_stub:
  virtual public StringDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~StringDef_stub();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );

  private:
    void operator=( const StringDef_stub& );
};



class StringDef_stub_clp :
  virtual public StringDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    StringDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~StringDef_stub_clp ();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );

  protected:
    StringDef_stub_clp ();
  private:
    void operator=( const StringDef_stub_clp & );
};





class WstringDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~WstringDef();


    typedef WstringDef_ptr _ptr_type;
    typedef WstringDef_var _var_type;


    static WstringDef_ptr _narrow( CORBA::Object_ptr obj );
    static WstringDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static WstringDef_ptr _duplicate( WstringDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static WstringDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;

  protected:
    WstringDef() {};
  private:
    WstringDef( const WstringDef& );
    void operator=( const WstringDef& );
};

extern CORBA::TypeCodeConst _tc_WstringDef;


class WstringDef_stub:
  virtual public WstringDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~WstringDef_stub();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );

  private:
    void operator=( const WstringDef_stub& );
};



class WstringDef_stub_clp :
  virtual public WstringDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    WstringDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~WstringDef_stub_clp ();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );

  protected:
    WstringDef_stub_clp ();
  private:
    void operator=( const WstringDef_stub_clp & );
};





class SequenceDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~SequenceDef();


    typedef SequenceDef_ptr _ptr_type;
    typedef SequenceDef_var _var_type;


    static SequenceDef_ptr _narrow( CORBA::Object_ptr obj );
    static SequenceDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static SequenceDef_ptr _duplicate( SequenceDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static SequenceDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;
    virtual CORBA::TypeCode_ptr element_type() = 0;
    virtual IDLType_ptr element_type_def() = 0;
    virtual void element_type_def( IDLType_ptr value ) = 0;

  protected:
    SequenceDef() {};
  private:
    SequenceDef( const SequenceDef& );
    void operator=( const SequenceDef& );
};

extern CORBA::TypeCodeConst _tc_SequenceDef;


class SequenceDef_stub:
  virtual public SequenceDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~SequenceDef_stub();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );
    CORBA::TypeCode_ptr element_type();
    IDLType_ptr element_type_def();
    void element_type_def( IDLType_ptr value );

  private:
    void operator=( const SequenceDef_stub& );
};



class SequenceDef_stub_clp :
  virtual public SequenceDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    SequenceDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~SequenceDef_stub_clp ();
    CORBA::ULong bound();
    void bound( CORBA::ULong value );
    CORBA::TypeCode_ptr element_type();
    IDLType_ptr element_type_def();
    void element_type_def( IDLType_ptr value );

  protected:
    SequenceDef_stub_clp ();
  private:
    void operator=( const SequenceDef_stub_clp & );
};





class ArrayDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~ArrayDef();


    typedef ArrayDef_ptr _ptr_type;
    typedef ArrayDef_var _var_type;


    static ArrayDef_ptr _narrow( CORBA::Object_ptr obj );
    static ArrayDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ArrayDef_ptr _duplicate( ArrayDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ArrayDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong length() = 0;
    virtual void length( CORBA::ULong value ) = 0;
    virtual CORBA::TypeCode_ptr element_type() = 0;
    virtual IDLType_ptr element_type_def() = 0;
    virtual void element_type_def( IDLType_ptr value ) = 0;

  protected:
    ArrayDef() {};
  private:
    ArrayDef( const ArrayDef& );
    void operator=( const ArrayDef& );
};

extern CORBA::TypeCodeConst _tc_ArrayDef;


class ArrayDef_stub:
  virtual public ArrayDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~ArrayDef_stub();
    CORBA::ULong length();
    void length( CORBA::ULong value );
    CORBA::TypeCode_ptr element_type();
    IDLType_ptr element_type_def();
    void element_type_def( IDLType_ptr value );

  private:
    void operator=( const ArrayDef_stub& );
};



class ArrayDef_stub_clp :
  virtual public ArrayDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    ArrayDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ArrayDef_stub_clp ();
    CORBA::ULong length();
    void length( CORBA::ULong value );
    CORBA::TypeCode_ptr element_type();
    IDLType_ptr element_type_def();
    void element_type_def( IDLType_ptr value );

  protected:
    ArrayDef_stub_clp ();
  private:
    void operator=( const ArrayDef_stub_clp & );
};





class FixedDef :
  virtual public ::CORBA::IDLType
{
  public:
    typedef ::CORBA::IDLType _VCHACK__CORBA__IDLType;
    virtual ~FixedDef();


    typedef FixedDef_ptr _ptr_type;
    typedef FixedDef_var _var_type;


    static FixedDef_ptr _narrow( CORBA::Object_ptr obj );
    static FixedDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FixedDef_ptr _duplicate( FixedDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FixedDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::UShort digits() = 0;
    virtual void digits( CORBA::UShort value ) = 0;
    virtual CORBA::Short scale() = 0;
    virtual void scale( CORBA::Short value ) = 0;

  protected:
    FixedDef() {};
  private:
    FixedDef( const FixedDef& );
    void operator=( const FixedDef& );
};

extern CORBA::TypeCodeConst _tc_FixedDef;


class FixedDef_stub:
  virtual public FixedDef,
  virtual public ::CORBA::IDLType_stub
{
  public:
    virtual ~FixedDef_stub();
    CORBA::UShort digits();
    void digits( CORBA::UShort value );
    CORBA::Short scale();
    void scale( CORBA::Short value );

  private:
    void operator=( const FixedDef_stub& );
};



class FixedDef_stub_clp :
  virtual public FixedDef_stub,
  virtual public ::CORBA::IDLType_stub_clp
{
  public:
    FixedDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FixedDef_stub_clp ();
    CORBA::UShort digits();
    void digits( CORBA::UShort value );
    CORBA::Short scale();
    void scale( CORBA::Short value );

  protected:
    FixedDef_stub_clp ();
  private:
    void operator=( const FixedDef_stub_clp & );
};



struct ModuleDescription;
typedef TVarVar<ModuleDescription> ModuleDescription_var;
typedef TVarOut<ModuleDescription> ModuleDescription_out;

struct ModuleDescription {

  typedef ModuleDescription_var _var_type;
# 2525 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
};

extern CORBA::TypeCodeConst _tc_ModuleDescription;

struct ConstantDescription;
typedef TVarVar<ConstantDescription> ConstantDescription_var;
typedef TVarOut<ConstantDescription> ConstantDescription_out;

struct ConstantDescription {

  typedef ConstantDescription_var _var_type;
# 2548 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var type;
  CORBA::Any value;
};

extern CORBA::TypeCodeConst _tc_ConstantDescription;

struct TypeDescription;
typedef TVarVar<TypeDescription> TypeDescription_var;
typedef TVarOut<TypeDescription> TypeDescription_out;

struct TypeDescription {

  typedef TypeDescription_var _var_type;
# 2573 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  CORBA::TypeCode_var type;
};

extern CORBA::TypeCodeConst _tc_TypeDescription;



class AttributeDef :
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~AttributeDef();


    typedef AttributeDef_ptr _ptr_type;
    typedef AttributeDef_var _var_type;


    static AttributeDef_ptr _narrow( CORBA::Object_ptr obj );
    static AttributeDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static AttributeDef_ptr _duplicate( AttributeDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static AttributeDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual IDLType_ptr type_def() = 0;
    virtual void type_def( IDLType_ptr value ) = 0;
    virtual AttributeMode mode() = 0;
    virtual void mode( AttributeMode value ) = 0;

  protected:
    AttributeDef() {};
  private:
    AttributeDef( const AttributeDef& );
    void operator=( const AttributeDef& );
};

extern CORBA::TypeCodeConst _tc_AttributeDef;


class AttributeDef_stub:
  virtual public AttributeDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~AttributeDef_stub();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    AttributeMode mode();
    void mode( AttributeMode value );

  private:
    void operator=( const AttributeDef_stub& );
};



class AttributeDef_stub_clp :
  virtual public AttributeDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    AttributeDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~AttributeDef_stub_clp ();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    AttributeMode mode();
    void mode( AttributeMode value );

  protected:
    AttributeDef_stub_clp ();
  private:
    void operator=( const AttributeDef_stub_clp & );
};





class OperationDef :
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~OperationDef();


    typedef OperationDef_ptr _ptr_type;
    typedef OperationDef_var _var_type;


    static OperationDef_ptr _narrow( CORBA::Object_ptr obj );
    static OperationDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static OperationDef_ptr _duplicate( OperationDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static OperationDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr result() = 0;
    virtual IDLType_ptr result_def() = 0;
    virtual void result_def( IDLType_ptr value ) = 0;
    virtual ParDescriptionSeq* params() = 0;
    virtual void params( const ParDescriptionSeq& value ) = 0;
    virtual OperationMode mode() = 0;
    virtual void mode( OperationMode value ) = 0;
    virtual ContextIdSeq* contexts() = 0;
    virtual void contexts( const ContextIdSeq& value ) = 0;
    virtual ExceptionDefSeq* exceptions() = 0;
    virtual void exceptions( const ExceptionDefSeq& value ) = 0;

  protected:
    OperationDef() {};
  private:
    OperationDef( const OperationDef& );
    void operator=( const OperationDef& );
};

extern CORBA::TypeCodeConst _tc_OperationDef;


class OperationDef_stub:
  virtual public OperationDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~OperationDef_stub();
    CORBA::TypeCode_ptr result();
    IDLType_ptr result_def();
    void result_def( IDLType_ptr value );
    ParDescriptionSeq* params();
    void params( const ParDescriptionSeq& value );
    OperationMode mode();
    void mode( OperationMode value );
    ContextIdSeq* contexts();
    void contexts( const ContextIdSeq& value );
    ExceptionDefSeq* exceptions();
    void exceptions( const ExceptionDefSeq& value );

  private:
    void operator=( const OperationDef_stub& );
};



class OperationDef_stub_clp :
  virtual public OperationDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    OperationDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~OperationDef_stub_clp ();
    CORBA::TypeCode_ptr result();
    IDLType_ptr result_def();
    void result_def( IDLType_ptr value );
    ParDescriptionSeq* params();
    void params( const ParDescriptionSeq& value );
    OperationMode mode();
    void mode( OperationMode value );
    ContextIdSeq* contexts();
    void contexts( const ContextIdSeq& value );
    ExceptionDefSeq* exceptions();
    void exceptions( const ExceptionDefSeq& value );

  protected:
    OperationDef_stub_clp ();
  private:
    void operator=( const OperationDef_stub_clp & );
};



struct InterfaceDescription;
typedef TVarVar<InterfaceDescription> InterfaceDescription_var;
typedef TVarOut<InterfaceDescription> InterfaceDescription_out;

struct InterfaceDescription {

  typedef InterfaceDescription_var _var_type;
# 2783 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryIdSeq base_interfaces;
};

extern CORBA::TypeCodeConst _tc_InterfaceDescription;



class ValueMemberDef :
  virtual public ::CORBA::Contained
{
  public:
    typedef ::CORBA::Contained _VCHACK__CORBA__Contained;
    virtual ~ValueMemberDef();


    typedef ValueMemberDef_ptr _ptr_type;
    typedef ValueMemberDef_var _var_type;


    static ValueMemberDef_ptr _narrow( CORBA::Object_ptr obj );
    static ValueMemberDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ValueMemberDef_ptr _duplicate( ValueMemberDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ValueMemberDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual IDLType_ptr type_def() = 0;
    virtual void type_def( IDLType_ptr value ) = 0;
    virtual Visibility access() = 0;
    virtual void access( Visibility value ) = 0;

  protected:
    ValueMemberDef() {};
  private:
    ValueMemberDef( const ValueMemberDef& );
    void operator=( const ValueMemberDef& );
};

extern CORBA::TypeCodeConst _tc_ValueMemberDef;


class ValueMemberDef_stub:
  virtual public ValueMemberDef,
  virtual public ::CORBA::Contained_stub
{
  public:
    virtual ~ValueMemberDef_stub();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    Visibility access();
    void access( Visibility value );

  private:
    void operator=( const ValueMemberDef_stub& );
};



class ValueMemberDef_stub_clp :
  virtual public ValueMemberDef_stub,
  virtual public ::CORBA::Contained_stub_clp
{
  public:
    ValueMemberDef_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ValueMemberDef_stub_clp ();
    CORBA::TypeCode_ptr type();
    IDLType_ptr type_def();
    void type_def( IDLType_ptr value );
    Visibility access();
    void access( Visibility value );

  protected:
    ValueMemberDef_stub_clp ();
  private:
    void operator=( const ValueMemberDef_stub_clp & );
};



struct ValueDescription;
typedef TVarVar<ValueDescription> ValueDescription_var;
typedef TVarOut<ValueDescription> ValueDescription_out;

struct ValueDescription {

  typedef ValueDescription_var _var_type;
# 2891 "../include/mico/ir.h"
  Identifier_var name;
  RepositoryId_var id;
  CORBA::Boolean is_abstract;
  CORBA::Boolean is_custom;
  RepositoryId_var defined_in;
  VersionSpec_var version;
  RepositoryIdSeq supported_interfaces;
  RepositoryIdSeq abstract_base_values;
  CORBA::Boolean is_truncatable;
  RepositoryId_var base_value;
};

extern CORBA::TypeCodeConst _tc_ValueDescription;

}




namespace POA_CORBA {


class Contained :
  virtual public POA_CORBA::IRObject
{
  public:
    virtual ~Contained ();
    CORBA::Contained_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Contained * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual char* id() = 0;
    virtual void id( const char* value ) = 0;
    virtual char* name() = 0;
    virtual void name( const char* value ) = 0;
    virtual char* version() = 0;
    virtual void version( const char* value ) = 0;
    virtual CORBA::Container_ptr defined_in() = 0;
    virtual char* absolute_name() = 0;
    virtual CORBA::Repository_ptr containing_repository() = 0;

    virtual CORBA::Contained::Description* describe() = 0;
    virtual void move( CORBA::Container_ptr new_container, const char* new_name, const char* new_version ) = 0;

  protected:
    Contained () {};

  private:
    Contained (const Contained &);
    void operator= (const Contained &);
};

class Container :
  virtual public POA_CORBA::IRObject
{
  public:
    virtual ~Container ();
    CORBA::Container_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Container * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::Contained_ptr lookup( const char* search_name ) = 0;
    virtual CORBA::ContainedSeq* contents( CORBA::DefinitionKind limit_type, CORBA::Boolean exclude_inherited ) = 0;
    virtual CORBA::ContainedSeq* lookup_name( const char* search_name, CORBA::Long levels_to_search, CORBA::DefinitionKind limit_type, CORBA::Boolean exclude_inherited ) = 0;
    virtual CORBA::Container::DescriptionSeq* describe_contents( CORBA::DefinitionKind limit_type, CORBA::Boolean exclude_inherited, CORBA::Long max_returned_objs ) = 0;
    virtual CORBA::ModuleDef_ptr create_module( const char* id, const char* name, const char* version ) = 0;
    virtual CORBA::ConstantDef_ptr create_constant( const char* id, const char* name, const char* version, CORBA::IDLType_ptr type, const CORBA::Any& value ) = 0;
    virtual CORBA::StructDef_ptr create_struct( const char* id, const char* name, const char* version, const CORBA::StructMemberSeq& members ) = 0;
    virtual CORBA::ExceptionDef_ptr create_exception( const char* id, const char* name, const char* version, const CORBA::StructMemberSeq& members ) = 0;
    virtual CORBA::UnionDef_ptr create_union( const char* id, const char* name, const char* version, CORBA::IDLType_ptr discriminator_type, const CORBA::UnionMemberSeq& members ) = 0;
    virtual CORBA::EnumDef_ptr create_enum( const char* id, const char* name, const char* version, const CORBA::EnumMemberSeq& members ) = 0;
    virtual CORBA::AliasDef_ptr create_alias( const char* id, const char* name, const char* version, CORBA::IDLType_ptr original_type ) = 0;
    virtual CORBA::InterfaceDef_ptr create_interface( const char* id, const char* name, const char* version, const CORBA::InterfaceDefSeq& base_interfaces ) = 0;
    virtual CORBA::AbstractInterfaceDef_ptr create_abstract_interface( const char* id, const char* name, const char* version, const CORBA::AbstractInterfaceDefSeq& base_interfaces ) = 0;
    virtual CORBA::LocalInterfaceDef_ptr create_local_interface( const char* id, const char* name, const char* version, const CORBA::LocalInterfaceDefSeq& base_interfaces ) = 0;
    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, const CORBA::InterfaceDefSeq& supported_interfaces, const CORBA::InitializerSeq& initializers ) = 0;
    virtual CORBA::ValueBoxDef_ptr create_value_box( const char* id, const char* name, const char* version, CORBA::IDLType_ptr original_type_def ) = 0;
    virtual CORBA::NativeDef_ptr create_native( const char* id, const char* name, const char* version ) = 0;

  protected:
    Container () {};

  private:
    Container (const Container &);
    void operator= (const Container &);
};

class Repository :
  virtual public POA_CORBA::Container
{
  public:
    virtual ~Repository ();
    CORBA::Repository_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Repository * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::Contained_ptr lookup_id( const char* search_id ) = 0;
    virtual CORBA::PrimitiveDef_ptr get_primitive( CORBA::PrimitiveKind kind ) = 0;
    virtual CORBA::StringDef_ptr create_string( CORBA::ULong bound ) = 0;
    virtual CORBA::WstringDef_ptr create_wstring( CORBA::ULong bound ) = 0;
    virtual CORBA::SequenceDef_ptr create_sequence( CORBA::ULong bound, CORBA::IDLType_ptr element_type ) = 0;
    virtual CORBA::ArrayDef_ptr create_array( CORBA::ULong length, CORBA::IDLType_ptr element_type ) = 0;
    virtual CORBA::FixedDef_ptr create_fixed( CORBA::UShort digits, CORBA::Short scale ) = 0;

  protected:
    Repository () {};

  private:
    Repository (const Repository &);
    void operator= (const Repository &);
};

class ModuleDef :
  virtual public POA_CORBA::Container,
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~ModuleDef ();
    CORBA::ModuleDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ModuleDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    ModuleDef () {};

  private:
    ModuleDef (const ModuleDef &);
    void operator= (const ModuleDef &);
};

class ConstantDef :
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~ConstantDef ();
    CORBA::ConstantDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ConstantDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual CORBA::IDLType_ptr type_def() = 0;
    virtual void type_def( CORBA::IDLType_ptr value ) = 0;
    virtual CORBA::Any* value() = 0;
    virtual void value( const CORBA::Any& value ) = 0;

  protected:
    ConstantDef () {};

  private:
    ConstantDef (const ConstantDef &);
    void operator= (const ConstantDef &);
};

class TypedefDef :
  virtual public POA_CORBA::Contained,
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~TypedefDef ();
    CORBA::TypedefDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static TypedefDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    TypedefDef () {};

  private:
    TypedefDef (const TypedefDef &);
    void operator= (const TypedefDef &);
};

class StructDef :
  virtual public POA_CORBA::TypedefDef,
  virtual public POA_CORBA::Container
{
  public:
    virtual ~StructDef ();
    CORBA::StructDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static StructDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::StructMemberSeq* members() = 0;
    virtual void members( const CORBA::StructMemberSeq& value ) = 0;

  protected:
    StructDef () {};

  private:
    StructDef (const StructDef &);
    void operator= (const StructDef &);
};

class ExceptionDef :
  virtual public POA_CORBA::Contained,
  virtual public POA_CORBA::Container
{
  public:
    virtual ~ExceptionDef ();
    CORBA::ExceptionDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ExceptionDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual CORBA::StructMemberSeq* members() = 0;
    virtual void members( const CORBA::StructMemberSeq& value ) = 0;

  protected:
    ExceptionDef () {};

  private:
    ExceptionDef (const ExceptionDef &);
    void operator= (const ExceptionDef &);
};

class UnionDef :
  virtual public POA_CORBA::TypedefDef,
  virtual public POA_CORBA::Container
{
  public:
    virtual ~UnionDef ();
    CORBA::UnionDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static UnionDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr discriminator_type() = 0;
    virtual CORBA::IDLType_ptr discriminator_type_def() = 0;
    virtual void discriminator_type_def( CORBA::IDLType_ptr value ) = 0;
    virtual CORBA::UnionMemberSeq* members() = 0;
    virtual void members( const CORBA::UnionMemberSeq& value ) = 0;

  protected:
    UnionDef () {};

  private:
    UnionDef (const UnionDef &);
    void operator= (const UnionDef &);
};

class EnumDef :
  virtual public POA_CORBA::TypedefDef
{
  public:
    virtual ~EnumDef ();
    CORBA::EnumDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static EnumDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::EnumMemberSeq* members() = 0;
    virtual void members( const CORBA::EnumMemberSeq& value ) = 0;

  protected:
    EnumDef () {};

  private:
    EnumDef (const EnumDef &);
    void operator= (const EnumDef &);
};

class AliasDef :
  virtual public POA_CORBA::TypedefDef
{
  public:
    virtual ~AliasDef ();
    CORBA::AliasDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static AliasDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::IDLType_ptr original_type_def() = 0;
    virtual void original_type_def( CORBA::IDLType_ptr value ) = 0;

  protected:
    AliasDef () {};

  private:
    AliasDef (const AliasDef &);
    void operator= (const AliasDef &);
};

class InterfaceDef :
  virtual public POA_CORBA::Container,
  virtual public POA_CORBA::Contained,
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~InterfaceDef ();
    CORBA::InterfaceDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static InterfaceDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::InterfaceDefSeq* base_interfaces() = 0;
    virtual void base_interfaces( const CORBA::InterfaceDefSeq& value ) = 0;

    virtual CORBA::Boolean is_a( const char* interface_id ) = 0;
    virtual CORBA::InterfaceDef::FullInterfaceDescription* describe_interface() = 0;
    virtual CORBA::AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, CORBA::IDLType_ptr type, CORBA::AttributeMode mode ) = 0;
    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 ) = 0;

  protected:
    InterfaceDef () {};

  private:
    InterfaceDef (const InterfaceDef &);
    void operator= (const InterfaceDef &);
};

class AbstractInterfaceDef :
  virtual public POA_CORBA::InterfaceDef
{
  public:
    virtual ~AbstractInterfaceDef ();
    CORBA::AbstractInterfaceDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static AbstractInterfaceDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    AbstractInterfaceDef () {};

  private:
    AbstractInterfaceDef (const AbstractInterfaceDef &);
    void operator= (const AbstractInterfaceDef &);
};

class LocalInterfaceDef :
  virtual public POA_CORBA::InterfaceDef
{
  public:
    virtual ~LocalInterfaceDef ();
    CORBA::LocalInterfaceDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static LocalInterfaceDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    LocalInterfaceDef () {};

  private:
    LocalInterfaceDef (const LocalInterfaceDef &);
    void operator= (const LocalInterfaceDef &);
};

class ValueDef :
  virtual public POA_CORBA::Container,
  virtual public POA_CORBA::Contained,
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~ValueDef ();
    CORBA::ValueDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ValueDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::InterfaceDefSeq* supported_interfaces() = 0;
    virtual void supported_interfaces( const CORBA::InterfaceDefSeq& value ) = 0;
    virtual CORBA::InitializerSeq* initializers() = 0;
    virtual void initializers( const CORBA::InitializerSeq& value ) = 0;
    virtual CORBA::ValueDef_ptr base_value() = 0;
    virtual void base_value( CORBA::ValueDef_ptr value ) = 0;
    virtual CORBA::ValueDefSeq* abstract_base_values() = 0;
    virtual void abstract_base_values( const CORBA::ValueDefSeq& value ) = 0;
    virtual CORBA::Boolean is_abstract() = 0;
    virtual void is_abstract( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean is_custom() = 0;
    virtual void is_custom( CORBA::Boolean value ) = 0;
    virtual CORBA::Boolean is_truncatable() = 0;
    virtual void is_truncatable( CORBA::Boolean value ) = 0;

    virtual CORBA::Boolean is_a( const char* value_id ) = 0;
    virtual CORBA::ValueDef::FullValueDescription* describe_value() = 0;
    virtual CORBA::ValueMemberDef_ptr create_value_member( const char* id, const char* name, const char* version, CORBA::IDLType_ptr type, CORBA::Visibility access ) = 0;
    virtual CORBA::AttributeDef_ptr create_attribute( const char* id, const char* name, const char* version, CORBA::IDLType_ptr type, CORBA::AttributeMode mode ) = 0;
    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 ) = 0;

  protected:
    ValueDef () {};

  private:
    ValueDef (const ValueDef &);
    void operator= (const ValueDef &);
};

class ValueBoxDef :
  virtual public POA_CORBA::TypedefDef
{
  public:
    virtual ~ValueBoxDef ();
    CORBA::ValueBoxDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ValueBoxDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::IDLType_ptr original_type_def() = 0;
    virtual void original_type_def( CORBA::IDLType_ptr value ) = 0;

  protected:
    ValueBoxDef () {};

  private:
    ValueBoxDef (const ValueBoxDef &);
    void operator= (const ValueBoxDef &);
};

class NativeDef :
  virtual public POA_CORBA::TypedefDef
{
  public:
    virtual ~NativeDef ();
    CORBA::NativeDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static NativeDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    NativeDef () {};

  private:
    NativeDef (const NativeDef &);
    void operator= (const NativeDef &);
};

class PrimitiveDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~PrimitiveDef ();
    CORBA::PrimitiveDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static PrimitiveDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::PrimitiveKind kind() = 0;

  protected:
    PrimitiveDef () {};

  private:
    PrimitiveDef (const PrimitiveDef &);
    void operator= (const PrimitiveDef &);
};

class StringDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~StringDef ();
    CORBA::StringDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static StringDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;

  protected:
    StringDef () {};

  private:
    StringDef (const StringDef &);
    void operator= (const StringDef &);
};

class WstringDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~WstringDef ();
    CORBA::WstringDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static WstringDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;

  protected:
    WstringDef () {};

  private:
    WstringDef (const WstringDef &);
    void operator= (const WstringDef &);
};

class SequenceDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~SequenceDef ();
    CORBA::SequenceDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static SequenceDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ULong bound() = 0;
    virtual void bound( CORBA::ULong value ) = 0;
    virtual CORBA::TypeCode_ptr element_type() = 0;
    virtual CORBA::IDLType_ptr element_type_def() = 0;
    virtual void element_type_def( CORBA::IDLType_ptr value ) = 0;

  protected:
    SequenceDef () {};

  private:
    SequenceDef (const SequenceDef &);
    void operator= (const SequenceDef &);
};

class ArrayDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~ArrayDef ();
    CORBA::ArrayDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ArrayDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::ULong length() = 0;
    virtual void length( CORBA::ULong value ) = 0;
    virtual CORBA::TypeCode_ptr element_type() = 0;
    virtual CORBA::IDLType_ptr element_type_def() = 0;
    virtual void element_type_def( CORBA::IDLType_ptr value ) = 0;

  protected:
    ArrayDef () {};

  private:
    ArrayDef (const ArrayDef &);
    void operator= (const ArrayDef &);
};

class FixedDef :
  virtual public POA_CORBA::IDLType
{
  public:
    virtual ~FixedDef ();
    CORBA::FixedDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FixedDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::UShort digits() = 0;
    virtual void digits( CORBA::UShort value ) = 0;
    virtual CORBA::Short scale() = 0;
    virtual void scale( CORBA::Short value ) = 0;

  protected:
    FixedDef () {};

  private:
    FixedDef (const FixedDef &);
    void operator= (const FixedDef &);
};

class AttributeDef :
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~AttributeDef ();
    CORBA::AttributeDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static AttributeDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual CORBA::IDLType_ptr type_def() = 0;
    virtual void type_def( CORBA::IDLType_ptr value ) = 0;
    virtual CORBA::AttributeMode mode() = 0;
    virtual void mode( CORBA::AttributeMode value ) = 0;

  protected:
    AttributeDef () {};

  private:
    AttributeDef (const AttributeDef &);
    void operator= (const AttributeDef &);
};

class OperationDef :
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~OperationDef ();
    CORBA::OperationDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static OperationDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr result() = 0;
    virtual CORBA::IDLType_ptr result_def() = 0;
    virtual void result_def( CORBA::IDLType_ptr value ) = 0;
    virtual CORBA::ParDescriptionSeq* params() = 0;
    virtual void params( const CORBA::ParDescriptionSeq& value ) = 0;
    virtual CORBA::OperationMode mode() = 0;
    virtual void mode( CORBA::OperationMode value ) = 0;
    virtual CORBA::ContextIdSeq* contexts() = 0;
    virtual void contexts( const CORBA::ContextIdSeq& value ) = 0;
    virtual CORBA::ExceptionDefSeq* exceptions() = 0;
    virtual void exceptions( const CORBA::ExceptionDefSeq& value ) = 0;

  protected:
    OperationDef () {};

  private:
    OperationDef (const OperationDef &);
    void operator= (const OperationDef &);
};

class ValueMemberDef :
  virtual public POA_CORBA::Contained
{
  public:
    virtual ~ValueMemberDef ();
    CORBA::ValueMemberDef_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ValueMemberDef * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::TypeCode_ptr type() = 0;
    virtual CORBA::IDLType_ptr type_def() = 0;
    virtual void type_def( CORBA::IDLType_ptr value ) = 0;
    virtual CORBA::Visibility access() = 0;
    virtual void access( CORBA::Visibility value ) = 0;

  protected:
    ValueMemberDef () {};

  private:
    ValueMemberDef (const ValueMemberDef &);
    void operator= (const ValueMemberDef &);
};

}




void operator<<=( CORBA::Any &_a, const ::CORBA::Contained::Description &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::Contained::Description *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::Contained::Description &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::Contained::Description *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Contained_Description;

void operator<<=( CORBA::Any &a, const CORBA::Contained_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::Contained_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::Contained_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Contained;

void operator<<=( CORBA::Any &_a, const ::CORBA::Initializer &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::Initializer *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::Initializer &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::Initializer *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Initializer;

void operator<<=( CORBA::Any &_a, const ::CORBA::Container::Description &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::Container::Description *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::Container::Description &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::Container::Description *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Container_Description;

void operator<<=( CORBA::Any &a, const CORBA::Container_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::Container_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::Container_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Container;

void operator<<=( CORBA::Any &a, const ::CORBA::PrimitiveKind &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::PrimitiveKind &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_PrimitiveKind;

void operator<<=( CORBA::Any &a, const CORBA::Repository_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::Repository_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::Repository_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_Repository;

void operator<<=( CORBA::Any &a, const CORBA::ModuleDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ModuleDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ModuleDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ModuleDef;

void operator<<=( CORBA::Any &a, const CORBA::ConstantDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ConstantDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ConstantDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ConstantDef;

void operator<<=( CORBA::Any &a, const CORBA::TypedefDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::TypedefDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::TypedefDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_TypedefDef;

void operator<<=( CORBA::Any &a, const CORBA::StructDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::StructDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::StructDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_StructDef;

void operator<<=( CORBA::Any &a, const CORBA::ExceptionDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ExceptionDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ExceptionDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ExceptionDef;

void operator<<=( CORBA::Any &a, const CORBA::UnionDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::UnionDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::UnionDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_UnionDef;

void operator<<=( CORBA::Any &a, const CORBA::EnumDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::EnumDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::EnumDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_EnumDef;

void operator<<=( CORBA::Any &a, const CORBA::AliasDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::AliasDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::AliasDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_AliasDef;

void operator<<=( CORBA::Any &a, const ::CORBA::OperationMode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::OperationMode &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_OperationMode;

void operator<<=( CORBA::Any &a, const ::CORBA::ParameterMode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::ParameterMode &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ParameterMode;

void operator<<=( CORBA::Any &_a, const ::CORBA::ParameterDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ParameterDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ParameterDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ParameterDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ParameterDescription;

void operator<<=( CORBA::Any &_a, const ::CORBA::ExceptionDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ExceptionDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ExceptionDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ExceptionDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ExceptionDescription;

void operator<<=( CORBA::Any &_a, const ::CORBA::OperationDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::OperationDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::OperationDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::OperationDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_OperationDescription;

void operator<<=( CORBA::Any &a, const ::CORBA::AttributeMode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::AttributeMode &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_AttributeMode;

void operator<<=( CORBA::Any &_a, const ::CORBA::AttributeDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::AttributeDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::AttributeDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::AttributeDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_AttributeDescription;

void operator<<=( CORBA::Any &_a, const ::CORBA::InterfaceDef::FullInterfaceDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::InterfaceDef::FullInterfaceDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::InterfaceDef::FullInterfaceDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::InterfaceDef::FullInterfaceDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_InterfaceDef_FullInterfaceDescription;

void operator<<=( CORBA::Any &a, const CORBA::InterfaceDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::InterfaceDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::InterfaceDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_InterfaceDef;

void operator<<=( CORBA::Any &a, const CORBA::AbstractInterfaceDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::AbstractInterfaceDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::AbstractInterfaceDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_AbstractInterfaceDef;

void operator<<=( CORBA::Any &a, const CORBA::LocalInterfaceDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::LocalInterfaceDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::LocalInterfaceDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_LocalInterfaceDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ValueDef::FullValueDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ValueDef::FullValueDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ValueDef::FullValueDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ValueDef::FullValueDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueDef_FullValueDescription;

void operator<<=( CORBA::Any &a, const CORBA::ValueDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ValueDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ValueDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueDef;

void operator<<=( CORBA::Any &a, const CORBA::ValueBoxDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ValueBoxDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ValueBoxDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueBoxDef;

void operator<<=( CORBA::Any &a, const CORBA::NativeDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::NativeDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::NativeDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_NativeDef;

void operator<<=( CORBA::Any &a, const CORBA::PrimitiveDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::PrimitiveDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::PrimitiveDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_PrimitiveDef;

void operator<<=( CORBA::Any &a, const CORBA::StringDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::StringDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::StringDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_StringDef;

void operator<<=( CORBA::Any &a, const CORBA::WstringDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::WstringDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::WstringDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_WstringDef;

void operator<<=( CORBA::Any &a, const CORBA::SequenceDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::SequenceDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::SequenceDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_SequenceDef;

void operator<<=( CORBA::Any &a, const CORBA::ArrayDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ArrayDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ArrayDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ArrayDef;

void operator<<=( CORBA::Any &a, const CORBA::FixedDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::FixedDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::FixedDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_FixedDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ModuleDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ModuleDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ModuleDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ModuleDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ModuleDescription;

void operator<<=( CORBA::Any &_a, const ::CORBA::ConstantDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ConstantDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ConstantDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ConstantDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ConstantDescription;

void operator<<=( CORBA::Any &_a, const ::CORBA::TypeDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::TypeDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::TypeDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::TypeDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_TypeDescription;

void operator<<=( CORBA::Any &a, const CORBA::AttributeDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::AttributeDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::AttributeDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_AttributeDef;

void operator<<=( CORBA::Any &a, const CORBA::OperationDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::OperationDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::OperationDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_OperationDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::InterfaceDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::InterfaceDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::InterfaceDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::InterfaceDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_InterfaceDescription;

void operator<<=( CORBA::Any &a, const CORBA::ValueMemberDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ValueMemberDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ValueMemberDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueMemberDef;

void operator<<=( CORBA::Any &_a, const ::CORBA::ValueDescription &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ValueDescription *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ValueDescription &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ValueDescription *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ValueDescription;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::Contained_var,CORBA::Contained_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::Contained_var,CORBA::Contained_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::Contained_var,CORBA::Contained_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::Contained_var,CORBA::Contained_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_Contained;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::Container::Description,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::Container::Description,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::Container::Description,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::Container::Description,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_Container_Description;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::InterfaceDef_var,CORBA::InterfaceDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::InterfaceDef_var,CORBA::InterfaceDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::InterfaceDef_var,CORBA::InterfaceDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::InterfaceDef_var,CORBA::InterfaceDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_InterfaceDef;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::AbstractInterfaceDef_var,CORBA::AbstractInterfaceDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::AbstractInterfaceDef_var,CORBA::AbstractInterfaceDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::AbstractInterfaceDef_var,CORBA::AbstractInterfaceDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::AbstractInterfaceDef_var,CORBA::AbstractInterfaceDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_AbstractInterfaceDef;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::LocalInterfaceDef_var,CORBA::LocalInterfaceDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::LocalInterfaceDef_var,CORBA::LocalInterfaceDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::LocalInterfaceDef_var,CORBA::LocalInterfaceDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::LocalInterfaceDef_var,CORBA::LocalInterfaceDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_LocalInterfaceDef;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ValueDef_var,CORBA::ValueDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ValueDef_var,CORBA::ValueDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ValueDef_var,CORBA::ValueDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ValueDef_var,CORBA::ValueDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ValueDef;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::Initializer,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::Initializer,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::Initializer,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::Initializer,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_Initializer;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::OperationDescription,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::OperationDescription,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::OperationDescription,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::OperationDescription,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_OperationDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ParameterDescription,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ParameterDescription,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ParameterDescription,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ParameterDescription,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ParameterDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ExceptionDescription,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ExceptionDescription,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ExceptionDescription,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ExceptionDescription,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ExceptionDescription;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::AttributeDescription,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::AttributeDescription,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::AttributeDescription,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::AttributeDescription,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_AttributeDescription;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ExceptionDef_var,CORBA::ExceptionDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ExceptionDef_var,CORBA::ExceptionDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ExceptionDef_var,CORBA::ExceptionDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ExceptionDef_var,CORBA::ExceptionDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ExceptionDef;
# 223 "../include/CORBA.h" 2

# 1 "../include/mico/service_info.h" 1
# 12 "../include/mico/service_info.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/service_info.h" 2



namespace CORBA {





typedef CORBA::UShort ServiceType;
typedef ServiceType& ServiceType_out;
typedef CORBA::ULong ServiceOption;
typedef ServiceOption& ServiceOption_out;
typedef CORBA::ULong ServiceDetailType;
typedef ServiceDetailType& ServiceDetailType_out;
extern const CORBA::UShort Security;
struct ServiceDetail;
typedef TVarVar<ServiceDetail> ServiceDetail_var;
typedef TVarOut<ServiceDetail> ServiceDetail_out;

struct ServiceDetail {

  typedef ServiceDetail_var _var_type;
# 44 "../include/mico/service_info.h"
  ServiceDetailType service_detail_type;
  typedef SequenceTmpl<CORBA::Octet,3> _service_detail_seq;
  _service_detail_seq service_detail;
};

struct ServiceInformation;
typedef TVarVar<ServiceInformation> ServiceInformation_var;
typedef TVarOut<ServiceInformation> ServiceInformation_out;

struct ServiceInformation {

  typedef ServiceInformation_var _var_type;
# 64 "../include/mico/service_info.h"
  typedef SequenceTmpl<ServiceOption,0> _service_options_seq;
  _service_options_seq service_options;
  typedef SequenceTmpl<ServiceDetail,0> _service_details_seq;
  _service_details_seq service_details;
};





}
# 89 "../include/mico/service_info.h"
# 1 "../include/mico/template_impl.h" 1
# 90 "../include/mico/service_info.h" 2
# 225 "../include/CORBA.h" 2
# 1 "../include/mico/orb_mico.h" 1
# 27 "../include/mico/orb_mico.h"
namespace CORBA {

class ObjectAdapter;

struct ORBCallback;

typedef ORBRequest *ORBRequest_ptr;
typedef ObjVar<ORBRequest> ORBRequest_var;
typedef ObjOut<ORBRequest> ORBRequest_out;


class PrincipalCurrent_impl : public CORBA::PrincipalCurrent {
public:
    CORBA::Principal_ptr get_principal ();
};


class ORBInvokeRec {
public:
    typedef ULong MsgId;
private:
    MsgId _myid;
    RequestType _type;
    Boolean _have_result;
    Object_ptr _obj;
    Object_ptr _target;
    Principal_ptr _principal;
    Boolean _response_expected;
    string _repoid;
    InvokeStatus _invoke_stat;
    LocateStatus _locate_stat;
    ObjectAdapter *_adapter;
    ORBRequest *_req;
    ORBCallback *_cb;
    ORB_ptr _orb;
    OctetSeq _objtag;
    Address *_addr;
    CORBA::GIOP::AddressingDisposition _ad;

public:
    ORBInvokeRec ();
    virtual ~ORBInvokeRec ();

    void free();

    void init_invoke (ORB_ptr, MsgId, Object_ptr target,
                      ORBRequest *, Principal_ptr pr,
                      Boolean response_expected,
                      ORBCallback *, ObjectAdapter * = 0);

    void init_locate (ORB_ptr, MsgId, Object_ptr,
                      ORBCallback *, ObjectAdapter * = 0);

    void init_bind (ORB_ptr, MsgId, const char *,
                    const OctetSeq &tag, Address *, ORBCallback *,
                    ObjectAdapter * = 0);

    MsgId id () const
    { return _myid; }

    Boolean completed () const
    { return _have_result; }

    ObjectAdapter *oa ()
    { return _adapter; }

    void oa (ObjectAdapter *oaval)
    { _adapter = oaval; }

    RequestType request_type ()
    { return _type; }

    ORBRequest *request ()
    { return _req; }

    const OctetSeq &tag () const
    { return _objtag; }

    ORBCallback *callback ()
    { return _cb; }

    Principal_ptr principal ()
    { return _principal; }

    void redo ();

    void set_answer_invoke (InvokeStatus, Object_ptr, ORBRequest *,
                            CORBA::GIOP::AddressingDisposition);
    void set_answer_bind (LocateStatus, Object_ptr);
    void set_answer_locate (LocateStatus, Object_ptr,
                            CORBA::GIOP::AddressingDisposition);

    Boolean get_answer_invoke (InvokeStatus &, Object_ptr &, ORBRequest *&,
                               CORBA::GIOP::AddressingDisposition &);
    Boolean get_answer_bind (LocateStatus &, Object_ptr &);
    Boolean get_answer_locate (LocateStatus &, Object_ptr &,
                               CORBA::GIOP::AddressingDisposition &);
};



class ORB : public ServerlessObject {
public:
    typedef CORBA::ULong MsgId;
private:
    typedef vector<ObjectAdapter *> OAVec;
    typedef map<MsgId, ORBInvokeRec *, less<MsgId> > InvokeMap;
    typedef map<string, Object_var, less<string> > InitialRefMap;
    typedef map<string, ValueFactoryBase_var, less<string> > ValueFactoryMap;

    string _default_init_ref;
    list<string> _isa_cache;
    vector<string> _bindaddrs;
    OAVec _adapters;
    InvokeMap _invokes;
    Dispatcher *_disp;
    IOR *_tmpl;
    MsgId _theid, _currentid;
    InitialRefMap _init_refs;
    string _rcfile;
    DomainManager_var _def_manager;
    ValueFactoryMap _value_facs;
    Boolean _is_running;
    Boolean _is_shutdown;
    Boolean _is_stopped;
    Boolean _wait_for_completion;
    OAVec _shutting_down_adapters;

    ORBInvokeRec *_cache_rec;
    CORBA::Boolean _cache_used;

    Boolean is_local (Object_ptr);
    ObjectAdapter *get_oa (Object_ptr);
    ORBInvokeRec *create_invoke ();
    void add_invoke (ORBInvokeRec *);
    ORBInvokeRec *get_invoke (MsgId);
    void del_invoke (MsgId);

    void do_shutdown ();

    CORBA::Object_ptr corbaloc_to_object (const char *);
    CORBA::Object_ptr corbaname_to_object (const char *);
    CORBA::Object_ptr iioploc_to_object (const char *);
    CORBA::Object_ptr iiopname_to_object (const char *);
    CORBA::Object_ptr file_to_object (const char *);
    CORBA::Object_ptr http_to_object (const char *);

    Boolean builtin_invoke (MsgId, Object_ptr,
                            ORBRequest *, Principal_ptr);
public:
    typedef IfaceSequenceTmpl<Request_var,Request_ptr> RequestSeq;
    typedef TSeqVar<RequestSeq> RequestSeq_var;

    typedef OctetSeq ObjectTag;
    typedef TSeqVar<ObjectTag> ObjectTag_var;

    ORB (int &argc, char **argv, const char *rcfile);
    virtual ~ORB ();

    char *object_to_string (Object_ptr);
    Object_ptr string_to_object (const char *);
    Object_ptr ior_to_object (IOR *);
    Boolean is_impl (Object_ptr);
    const char *rcfile();

    static char *tag_to_string (const ObjectTag &);
    static ObjectTag *string_to_tag (const char *);

    void create_list (Long, NVList_out);
    void create_operation_list (OperationDef *,
                                NVList_out);
    void create_named_value (NamedValue_out);
    void create_exception_list (ExceptionList_out);
    void create_context_list (ContextList_out);
    void create_environment (Environment_out);

    void get_default_context (Context_out);


    void get_default_domain_manager (DomainManager_out);

    CORBA::Boolean get_service_information (
        CORBA::ServiceType service_type,
        CORBA::ServiceInformation_out service_information);

    void send_multiple_requests_oneway (const RequestSeq &);
    void send_multiple_requests_deferred (const RequestSeq &);
    Boolean poll_next_response ();
    void get_next_response (Request_out);

    Boolean work_pending ();
    void perform_work ();
    void run ();
    void shutdown (Boolean wait_for_completion);
    void destroy ();

    typedef char *OAid;
    BOA_ptr BOA_init (int &argc, char **argv, const char *boa_id = "");
    BOA_ptr BOA_instance (const char *id, Boolean create=1);

    typedef CORBA::ORB_InvalidName InvalidName;
    typedef CORBA::ORB_InvalidName_catch InvalidName_catch;

    typedef char *ObjectId;
    typedef StringSequenceTmpl<String_var> ObjectIdList;
    typedef ObjectIdList *ObjectIdList_ptr;
    typedef TSeqVar<ObjectIdList> ObjectIdList_var;

    ObjectIdList_ptr list_initial_services ();
    Object_ptr resolve_initial_references (const char *id);
    Boolean set_initial_reference (const char *id, Object_ptr obj);
    Boolean set_default_initial_reference (const char *);

    virtual TypeCode_ptr create_struct_tc (const char *rep_id,
                                           const char *name,
                                           const StructMemberSeq &);
    virtual TypeCode_ptr create_union_tc (const char *rep_id,
                                          const char *name,
                                          TypeCode_ptr disc_type,
                                          const UnionMemberSeq &);
    virtual TypeCode_ptr create_enum_tc (const char *rep_id,
                                         const char *name,
                                         const EnumMemberSeq &);
    virtual TypeCode_ptr create_exception_tc (const char *rep_id,
                                              const char *name,
                                              const StructMemberSeq &);
    virtual TypeCode_ptr create_alias_tc (const char *rep_id,
                                          const char *name,
                                          TypeCode_ptr orig_type);
    virtual TypeCode_ptr create_interface_tc (const char *rep_id,
                                              const char *name);
    virtual TypeCode_ptr create_string_tc (ULong bound);
    virtual TypeCode_ptr create_wstring_tc (ULong bound);
    virtual TypeCode_ptr create_fixed_tc (UShort digits, Short scale);
    virtual TypeCode_ptr create_sequence_tc (ULong bound,
                                             TypeCode_ptr el_type);
    virtual TypeCode_ptr create_recursive_sequence_tc (ULong bound,
                                                       ULong offset);
    virtual TypeCode_ptr create_array_tc (ULong length,
                                          TypeCode_ptr el_type);
    virtual TypeCode_ptr create_value_tc (const char *rep_id, const char *name,
                                          ValueModifier mod,
                                          TypeCode_ptr concrete_base,
                                          const ValueMemberSeq &members);
    virtual TypeCode_ptr create_value_box_tc (const char *rep_id,
                                              const char *name,
                                              TypeCode_ptr boxed_type);
    virtual TypeCode_ptr create_native_tc (const char *rep_id,
                                           const char *name);
    virtual TypeCode_ptr create_recursive_tc (const char *rep_id);
    virtual TypeCode_ptr create_abstract_interface_tc (const char *rep_id,
                                                       const char *name);


    ValueFactory register_value_factory (const char *repoid,
                                         ValueFactory factory);
    void unregister_value_factory (const char *repoid);
    ValueFactory lookup_value_factory (const char *repoid);


    CORBA::Policy_ptr create_policy (CORBA::PolicyType type,
                                     const CORBA::Any &any);


    const vector<string> &bindaddrs () const
    {
        return _bindaddrs;
    }
    void bindaddrs (const vector<string> &b)
    {
        _bindaddrs = b;
    }

    void dispatcher (Dispatcher *);
    Dispatcher *dispatcher ()
    {
        return _disp;
    }
    IOR *ior_template ()
    {
        return _tmpl;
    }

    void register_oa (ObjectAdapter *);
    void unregister_oa (ObjectAdapter *);

    void register_profile_id (CORBA::ULong id);
    void unregister_profile_id (CORBA::ULong id);

    MsgId new_msgid ();

    MsgId invoke_async (Object_ptr, ORBRequest *, Principal_ptr,
                        Boolean rply = 1, ORBCallback * = 0,
                        MsgId = 0);
    MsgId locate_async (Object_ptr, ORBCallback * = 0, MsgId = 0);
    MsgId bind_async (const char *repoid, const ObjectTag &,
                      Address *, ORBCallback * = 0, MsgId = 0);

    InvokeStatus invoke (Object_ptr &, ORBRequest *, Principal_ptr,
                         Boolean rply = 1);
    LocateStatus locate (Object_ptr &);
    LocateStatus bind (const char *repoid, const ObjectTag &,
                       Address *, Object_ptr &);
    Object_ptr bind (const char *repoid, const char *addr = 0);
    Object_ptr bind (const char *repoid, const ObjectTag &,
                     const char *addr = 0);

    void cancel (MsgId);
    Boolean wait (MsgId, Long tmout = -1);
    Long wait (vector<MsgId> &, Long tmout = -1);

    void answer_invoke (MsgId, InvokeStatus, Object_ptr, ORBRequest *,
                        CORBA::GIOP::AddressingDisposition);
    void answer_bind (MsgId, LocateStatus, Object_ptr);
    void answer_locate (MsgId, LocateStatus, Object_ptr,
                        CORBA::GIOP::AddressingDisposition);
    void answer_shutdown (ObjectAdapter *);

    InvokeStatus get_invoke_reply (MsgId, Object_out, ORBRequest *&,
                                   CORBA::GIOP::AddressingDisposition &);
    LocateStatus get_locate_reply (MsgId, Object_out,
                                   CORBA::GIOP::AddressingDisposition &);
    LocateStatus get_bind_reply (MsgId, Object_out);

    RequestType request_type (MsgId);
    void redo_request (MsgId);

    ImplementationDef *get_impl (Object_ptr);
    InterfaceDef *get_iface (Object_ptr);
    Boolean is_a (Object_ptr, const char *repoid);
    Boolean non_existent (Object_ptr);

    ORBInvokeRec *get_current_invoke_rec ();


    static ORB_ptr _duplicate (ORB_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static ORB_ptr _nil ()
    {
        return 0;
    }
};

typedef ObjVar<ORB> ORB_var;
typedef ObjOut<ORB> ORB_out;



typedef char *ORBid;
extern ORB_ptr ORB_init (int &argc, char **argv,
                                       const char *id = "");
extern ORB_ptr ORB_instance (const char *id, Boolean create=1);


class ObjectAdapter {
public:
    typedef CORBA::ULong MsgId;

    virtual const char *get_oaid () const = 0;
    virtual Boolean has_object (Object_ptr) = 0;
    virtual Boolean is_local () const = 0;

    virtual Boolean invoke (MsgId, Object_ptr, ORBRequest *,
                            Principal_ptr, Boolean response_exp = 1) = 0;
    virtual Boolean bind (MsgId, const char *repoid,
                          const ORB::ObjectTag &,
                          Address *addr) = 0;
    virtual Boolean locate (MsgId, Object_ptr) = 0;
    virtual Object_ptr skeleton (Object_ptr) = 0;
    virtual void cancel (MsgId) = 0;
    virtual void shutdown (Boolean wait_for_completion) = 0;

    virtual void answer_invoke (CORBA::ULong, CORBA::Object_ptr,
                                CORBA::ORBRequest *,
                                CORBA::InvokeStatus) = 0;

    virtual ~ObjectAdapter ();
};

}
# 226 "../include/CORBA.h" 2

# 1 "../include/mico/imr.h" 1
# 12 "../include/mico/imr.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/imr.h" 2



namespace CORBA {





class ImplementationDef;
typedef ImplementationDef *ImplementationDef_ptr;
typedef ImplementationDef_ptr ImplementationDefRef;
typedef ObjVar<ImplementationDef> ImplementationDef_var;
typedef ObjOut<ImplementationDef> ImplementationDef_out;



class ImplementationDef :
  virtual public CORBA::Object
{
  public:
    virtual ~ImplementationDef();


    typedef ImplementationDef_ptr _ptr_type;
    typedef ImplementationDef_var _var_type;


    static ImplementationDef_ptr _narrow( CORBA::Object_ptr obj );
    static ImplementationDef_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ImplementationDef_ptr _duplicate( ImplementationDef_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ImplementationDef_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    enum ActivationMode {
      ActivateShared = 0,
      ActivateUnshared,
      ActivatePerMethod,
      ActivatePersistent,
      ActivateLibrary,
      ActivatePOA
    };

    typedef ActivationMode& ActivationMode_out;

    static CORBA::TypeCodeConst _tc_ActivationMode;

    typedef SequenceTmpl<CORBA::Octet,3> ObjectTag;



    typedef TSeqVar<SequenceTmpl<CORBA::Octet,3> > ObjectTag_var;
    typedef TSeqOut<SequenceTmpl<CORBA::Octet,3> > ObjectTag_out;

    static CORBA::TypeCodeConst _tc_ObjectTag;

    struct ObjectInfo;
    typedef TVarVar<ObjectInfo> ObjectInfo_var;
    typedef TVarOut<ObjectInfo> ObjectInfo_out;

    struct ObjectInfo {

      typedef ObjectInfo_var _var_type;
# 95 "../include/mico/imr.h"
      CORBA::String_var repoid;
      ObjectTag tag;
    };

    static CORBA::TypeCodeConst _tc_ObjectInfo;

    typedef SequenceTmpl<ObjectInfo,0> ObjectInfoList;



    typedef TSeqVar<SequenceTmpl<ObjectInfo,0> > ObjectInfoList_var;
    typedef TSeqOut<SequenceTmpl<ObjectInfo,0> > ObjectInfoList_out;

    static CORBA::TypeCodeConst _tc_ObjectInfoList;

    virtual ActivationMode mode() = 0;
    virtual void mode( ActivationMode value ) = 0;
    virtual ObjectInfoList* objs() = 0;
    virtual void objs( const ObjectInfoList& value ) = 0;
    virtual char* name() = 0;
    virtual char* command() = 0;
    virtual void command( const char* value ) = 0;
    virtual char* tostring() = 0;

  protected:
    ImplementationDef() {};
  private:
    ImplementationDef( const ImplementationDef& );
    void operator=( const ImplementationDef& );
};

extern CORBA::TypeCodeConst _tc_ImplementationDef;


class ImplementationDef_stub:
  virtual public ImplementationDef
{
  public:
    virtual ~ImplementationDef_stub();
    ActivationMode mode();
    void mode( ActivationMode value );
    ObjectInfoList* objs();
    void objs( const ObjectInfoList& value );
    char* name();
    char* command();
    void command( const char* value );
    char* tostring();

  private:
    void operator=( const ImplementationDef_stub& );
};

class ImplementationDef_skel :
  virtual public StaticMethodDispatcher,
  virtual public ImplementationDef
{
  public:
    ImplementationDef_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~ImplementationDef_skel();
    ImplementationDef_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    ImplementationDef_ptr _this();

};

class ImplRepository;
typedef ImplRepository *ImplRepository_ptr;
typedef ImplRepository_ptr ImplRepositoryRef;
typedef ObjVar<ImplRepository> ImplRepository_var;
typedef ObjOut<ImplRepository> ImplRepository_out;



class ImplRepository :
  virtual public CORBA::Object
{
  public:
    virtual ~ImplRepository();


    typedef ImplRepository_ptr _ptr_type;
    typedef ImplRepository_var _var_type;


    static ImplRepository_ptr _narrow( CORBA::Object_ptr obj );
    static ImplRepository_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ImplRepository_ptr _duplicate( ImplRepository_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ImplRepository_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    typedef IfaceSequenceTmpl<ImplementationDef_var,ImplementationDef_ptr> ImplDefSeq;



    typedef TSeqVar<IfaceSequenceTmpl<ImplementationDef_var,ImplementationDef_ptr> > ImplDefSeq_var;
    typedef TSeqOut<IfaceSequenceTmpl<ImplementationDef_var,ImplementationDef_ptr> > ImplDefSeq_out;

    static CORBA::TypeCodeConst _tc_ImplDefSeq;

    virtual ImplementationDef_ptr restore( const char* asstring ) = 0;
    virtual ImplementationDef_ptr create( ImplementationDef::ActivationMode mode, const ImplementationDef::ObjectInfoList& objs, const char* name, const char* command ) = 0;
    virtual void destroy( ImplementationDef_ptr impl_def ) = 0;
    virtual ImplDefSeq* find_by_name( const char* name ) = 0;
    virtual ImplDefSeq* find_by_repoid( const char* repoid ) = 0;
    virtual ImplDefSeq* find_by_repoid_tag( const char* repoid, const ImplementationDef::ObjectTag& tag ) = 0;
    virtual ImplDefSeq* find_all() = 0;

  protected:
    ImplRepository() {};
  private:
    ImplRepository( const ImplRepository& );
    void operator=( const ImplRepository& );
};

extern CORBA::TypeCodeConst _tc_ImplRepository;


class ImplRepository_stub:
  virtual public ImplRepository
{
  public:
    virtual ~ImplRepository_stub();
    ImplementationDef_ptr restore( const char* asstring );
    ImplementationDef_ptr create( ImplementationDef::ActivationMode mode, const ImplementationDef::ObjectInfoList& objs, const char* name, const char* command );
    void destroy( ImplementationDef_ptr impl_def );
    ImplDefSeq* find_by_name( const char* name );
    ImplDefSeq* find_by_repoid( const char* repoid );
    ImplDefSeq* find_by_repoid_tag( const char* repoid, const ImplementationDef::ObjectTag& tag );
    ImplDefSeq* find_all();

  private:
    void operator=( const ImplRepository_stub& );
};

class ImplRepository_skel :
  virtual public StaticMethodDispatcher,
  virtual public ImplRepository
{
  public:
    ImplRepository_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~ImplRepository_skel();
    ImplRepository_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    ImplRepository_ptr _this();

};

class OAServer;
typedef OAServer *OAServer_ptr;
typedef OAServer_ptr OAServerRef;
typedef ObjVar<OAServer> OAServer_var;
typedef ObjOut<OAServer> OAServer_out;



class OAServer :
  virtual public CORBA::Object
{
  public:
    virtual ~OAServer();


    typedef OAServer_ptr _ptr_type;
    typedef OAServer_var _var_type;


    static OAServer_ptr _narrow( CORBA::Object_ptr obj );
    static OAServer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static OAServer_ptr _duplicate( OAServer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static OAServer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    typedef IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> ObjSeq;



    typedef TSeqVar<IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> > ObjSeq_var;
    typedef TSeqOut<IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> > ObjSeq_out;

    static CORBA::TypeCodeConst _tc_ObjSeq;

    virtual void restore_request( const ObjSeq& objs ) = 0;
    virtual void obj_inactive( CORBA::Object_ptr obj ) = 0;
    virtual void impl_inactive() = 0;

  protected:
    OAServer() {};
  private:
    OAServer( const OAServer& );
    void operator=( const OAServer& );
};

extern CORBA::TypeCodeConst _tc_OAServer;


class OAServer_stub:
  virtual public OAServer
{
  public:
    virtual ~OAServer_stub();
    void restore_request( const ObjSeq& objs );
    void obj_inactive( CORBA::Object_ptr obj );
    void impl_inactive();

  private:
    void operator=( const OAServer_stub& );
};

class OAServer_skel :
  virtual public StaticMethodDispatcher,
  virtual public OAServer
{
  public:
    OAServer_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~OAServer_skel();
    OAServer_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    OAServer_ptr _this();

};

class OAMediator;
typedef OAMediator *OAMediator_ptr;
typedef OAMediator_ptr OAMediatorRef;
typedef ObjVar<OAMediator> OAMediator_var;
typedef ObjOut<OAMediator> OAMediator_out;



class OAMediator :
  virtual public CORBA::Object
{
  public:
    virtual ~OAMediator();


    typedef OAMediator_ptr _ptr_type;
    typedef OAMediator_var _var_type;


    static OAMediator_ptr _narrow( CORBA::Object_ptr obj );
    static OAMediator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static OAMediator_ptr _duplicate( OAMediator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static OAMediator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    typedef SequenceTmpl<CORBA::Octet,3> RefData;



    typedef TSeqVar<SequenceTmpl<CORBA::Octet,3> > RefData_var;
    typedef TSeqOut<SequenceTmpl<CORBA::Octet,3> > RefData_out;

    static CORBA::TypeCodeConst _tc_RefData;

    typedef IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> ObjSeq;



    typedef TSeqVar<IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> > ObjSeq_var;
    typedef TSeqOut<IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> > ObjSeq_out;

    static CORBA::TypeCodeConst _tc_ObjSeq;

    typedef CORBA::ULong ServerId;
    typedef ServerId& ServerId_out;
    static CORBA::TypeCodeConst _tc_ServerId;

    virtual void create_obj( CORBA::Object_ptr objref, const RefData& id, CORBA::Object_out remote_objref, ServerId svid ) = 0;
    virtual void restore_obj( CORBA::Object_ptr objref, CORBA::Object_ptr& remote_objref, RefData_out id, ServerId svid ) = 0;
    virtual void activate_obj( CORBA::Object_ptr objref, ServerId svid ) = 0;
    virtual void deactivate_obj( CORBA::Object_ptr objref, ServerId svid ) = 0;
    virtual void migrate_obj( CORBA::Object_ptr objref, ServerId svid, ImplementationDef_ptr impl ) = 0;
    virtual void orphan_obj( CORBA::Object_ptr objref, ServerId svid ) = 0;
    virtual void dispose_obj( CORBA::Object_ptr objref, ServerId svid ) = 0;
    virtual void create_impl( ImplementationDef_ptr impl, OAServer_ptr server, ServerId& id ) = 0;
    virtual void activate_impl( ServerId id ) = 0;
    virtual void deactivate_impl( ServerId id ) = 0;
    virtual CORBA::Object_ptr get_remote_object( const RefData& key ) = 0;
    virtual void dispose_impl( ServerId id ) = 0;
    virtual ObjSeq* get_restore_objs( ServerId id ) = 0;
    virtual CORBA::Boolean force_activation( ImplementationDef_ptr impl ) = 0;

  protected:
    OAMediator() {};
  private:
    OAMediator( const OAMediator& );
    void operator=( const OAMediator& );
};

extern CORBA::TypeCodeConst _tc_OAMediator;


class OAMediator_stub:
  virtual public OAMediator
{
  public:
    virtual ~OAMediator_stub();
    void create_obj( CORBA::Object_ptr objref, const RefData& id, CORBA::Object_out remote_objref, ServerId svid );
    void restore_obj( CORBA::Object_ptr objref, CORBA::Object_ptr& remote_objref, RefData_out id, ServerId svid );
    void activate_obj( CORBA::Object_ptr objref, ServerId svid );
    void deactivate_obj( CORBA::Object_ptr objref, ServerId svid );
    void migrate_obj( CORBA::Object_ptr objref, ServerId svid, ImplementationDef_ptr impl );
    void orphan_obj( CORBA::Object_ptr objref, ServerId svid );
    void dispose_obj( CORBA::Object_ptr objref, ServerId svid );
    void create_impl( ImplementationDef_ptr impl, OAServer_ptr server, ServerId& id );
    void activate_impl( ServerId id );
    void deactivate_impl( ServerId id );
    CORBA::Object_ptr get_remote_object( const RefData& key );
    void dispose_impl( ServerId id );
    ObjSeq* get_restore_objs( ServerId id );
    CORBA::Boolean force_activation( ImplementationDef_ptr impl );

  private:
    void operator=( const OAMediator_stub& );
};

class OAMediator_skel :
  virtual public StaticMethodDispatcher,
  virtual public OAMediator
{
  public:
    OAMediator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~OAMediator_skel();
    OAMediator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    OAMediator_ptr _this();

};

class POAMediator;
typedef POAMediator *POAMediator_ptr;
typedef POAMediator_ptr POAMediatorRef;
typedef ObjVar<POAMediator> POAMediator_var;
typedef ObjOut<POAMediator> POAMediator_out;



class POAMediator :
  virtual public CORBA::Object
{
  public:
    virtual ~POAMediator();


    typedef POAMediator_ptr _ptr_type;
    typedef POAMediator_var _var_type;


    static POAMediator_ptr _narrow( CORBA::Object_ptr obj );
    static POAMediator_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static POAMediator_ptr _duplicate( POAMediator_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static POAMediator_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    virtual char* create_impl( const char* svid, const char* ior ) = 0;
    virtual void activate_impl( const char* svid ) = 0;
    virtual void deactivate_impl( const char* svid ) = 0;
    virtual CORBA::Boolean force_activation( ImplementationDef_ptr impl ) = 0;

  protected:
    POAMediator() {};
  private:
    POAMediator( const POAMediator& );
    void operator=( const POAMediator& );
};

extern CORBA::TypeCodeConst _tc_POAMediator;


class POAMediator_stub:
  virtual public POAMediator
{
  public:
    virtual ~POAMediator_stub();
    char* create_impl( const char* svid, const char* ior );
    void activate_impl( const char* svid );
    void deactivate_impl( const char* svid );
    CORBA::Boolean force_activation( ImplementationDef_ptr impl );

  private:
    void operator=( const POAMediator_stub& );
};

class POAMediator_skel :
  virtual public StaticMethodDispatcher,
  virtual public POAMediator
{
  public:
    POAMediator_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~POAMediator_skel();
    POAMediator_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    POAMediator_ptr _this();

};





}
# 551 "../include/mico/imr.h"
void operator<<=( CORBA::Any &a, const ::CORBA::ImplementationDef::ActivationMode &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, ::CORBA::ImplementationDef::ActivationMode &e );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ImplementationDef_ActivationMode;

void operator<<=( CORBA::Any &_a, const ::CORBA::ImplementationDef::ObjectInfo &_s );
void operator<<=( CORBA::Any &_a, ::CORBA::ImplementationDef::ObjectInfo *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CORBA::ImplementationDef::ObjectInfo &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CORBA::ImplementationDef::ObjectInfo *&_s );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ImplementationDef_ObjectInfo;

void operator<<=( CORBA::Any &a, const CORBA::ImplementationDef_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ImplementationDef_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ImplementationDef_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ImplementationDef;

void operator<<=( CORBA::Any &a, const CORBA::ImplRepository_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::ImplRepository_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::ImplRepository_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_ImplRepository;

void operator<<=( CORBA::Any &a, const CORBA::OAServer_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::OAServer_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::OAServer_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_OAServer;

void operator<<=( CORBA::Any &a, const CORBA::OAMediator_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::OAMediator_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::OAMediator_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_OAMediator;

void operator<<=( CORBA::Any &a, const CORBA::POAMediator_ptr obj );
void operator<<=( CORBA::Any &a, CORBA::POAMediator_ptr* obj_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, CORBA::POAMediator_ptr &obj );

extern CORBA::StaticTypeInfo *_marshaller_CORBA_POAMediator;

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,3> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::Octet,3> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::Octet,3> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::Octet,3> *&_s );

void operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ImplementationDef::ObjectInfo,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ImplementationDef::ObjectInfo,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ImplementationDef::ObjectInfo,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<CORBA::ImplementationDef::ObjectInfo,0> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ImplementationDef_ObjectInfo;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ImplementationDef_var,CORBA::ImplementationDef_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ImplementationDef_var,CORBA::ImplementationDef_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::ImplementationDef_var,CORBA::ImplementationDef_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::ImplementationDef_var,CORBA::ImplementationDef_ptr> *&_s );

extern CORBA::StaticTypeInfo *_marshaller__seq_CORBA_ImplementationDef;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> &_s );
void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> *&_s );





# 1 "../include/mico/template_impl.h" 1
# 623 "../include/mico/imr.h" 2
# 228 "../include/CORBA.h" 2

# 1 "../include/mico/valuetype_impl.h" 1
# 27 "../include/mico/valuetype_impl.h"
namespace CORBA {

class StringValue_Factory : virtual public ValueFactoryBase
{
public:
  ValueBase * create_for_unmarshal ();
};

class WStringValue_Factory : virtual public ValueFactoryBase
{
public:
  ValueBase * create_for_unmarshal ();
};

class DataOutputStream_impl :
  virtual public DataOutputStream,
  virtual public DefaultValueRefCountBase
{
public:
  DataOutputStream_impl (DataEncoder &);
  ~DataOutputStream_impl ();

  void write_any( const CORBA::Any& value );
  void write_boolean( CORBA::Boolean value );
  void write_char( CORBA::Char value );
  void write_wchar( CORBA::WChar value );
  void write_octet( CORBA::Octet value );
  void write_short( CORBA::Short value );
  void write_ushort( CORBA::UShort value );
  void write_long( CORBA::Long value );
  void write_ulong( CORBA::ULong value );
  void write_longlong( CORBA::LongLong value );
  void write_ulonglong( CORBA::ULongLong value );
  void write_float( CORBA::Float value );
  void write_double( CORBA::Double value );
  void write_longdouble( CORBA::LongDouble value );
  void write_string( const char* value );
  void write_wstring( const CORBA::WChar* value );
  void write_Object( CORBA::Object_ptr value );
  void write_Abstract( CORBA::AbstractBase* value );
  void write_Value( CORBA::ValueBase* value );
  void write_TypeCode( CORBA::TypeCode_ptr value );
  void write_any_array( const AnySeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_boolean_array( const BooleanSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_char_array( const CharSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_wchar_array( const WCharSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_octet_array( const OctetSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_short_array( const ShortSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_ushort_array( const UShortSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_long_array( const LongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_ulong_array( const ULongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_longlong_array( const LongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_ulonglong_array( const ULongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_float_array( const FloatSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void write_double_array( const DoubleSeq& seq, CORBA::ULong offset, CORBA::ULong length );

private:
  DataEncoder *ec;
};

class DataInputStream_impl :
  virtual public DataInputStream,
  virtual public DefaultValueRefCountBase
{
public:
  DataInputStream_impl (DataDecoder &);
  ~DataInputStream_impl ();

  CORBA::Boolean is_okay () const;

  CORBA::Any* read_any();
  CORBA::Boolean read_boolean();
  CORBA::Char read_char();
  CORBA::WChar read_wchar();
  CORBA::Octet read_octet();
  CORBA::Short read_short();
  CORBA::UShort read_ushort();
  CORBA::Long read_long();
  CORBA::ULong read_ulong();
  CORBA::LongLong read_longlong();
  CORBA::ULongLong read_ulonglong();
  CORBA::Float read_float();
  CORBA::Double read_double();
  CORBA::LongDouble read_longdouble();
  char* read_string();
  CORBA::WChar* read_wstring();
  CORBA::Object_ptr read_Object();
  CORBA::AbstractBase* read_Abstract();
  CORBA::ValueBase* read_Value();
  CORBA::TypeCode_ptr read_TypeCode();
  void read_any_array( AnySeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_boolean_array( BooleanSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_char_array( CharSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_wchar_array( WCharSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_octet_array( OctetSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_short_array( ShortSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_ushort_array( UShortSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_long_array( LongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_ulong_array( ULongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_longlong_array( LongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_ulonglong_array( ULongLongSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_float_array( FloatSeq& seq, CORBA::ULong offset, CORBA::ULong length );
  void read_double_array( DoubleSeq& seq, CORBA::ULong offset, CORBA::ULong length );

private:
  Boolean okay;
  DataDecoder *dc;
};

}
# 230 "../include/CORBA.h" 2




# 1 "../include/mico/dynany.h" 1







# 1 "../include/CORBA.h" 1
# 9 "../include/mico/dynany.h" 2





namespace DynamicAny {


class DynAny;
typedef DynAny *DynAny_ptr;
typedef DynAny_ptr DynAnyRef;
typedef ObjVar<DynAny> DynAny_var;
typedef ObjOut<DynAny> DynAny_out;



class DynAny :
  virtual public CORBA::LocalObject
{
  public:
    virtual ~DynAny();


    typedef DynAny_ptr _ptr_type;
    typedef DynAny_var _var_type;


    static DynAny_ptr _narrow( CORBA::Object_ptr obj );
    static DynAny_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynAny_ptr _duplicate( DynAny_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynAny_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct InvalidValue : public CORBA::UserException {
# 61 "../include/mico/dynany.h"
      InvalidValue *operator->() { return this; }
      InvalidValue& operator*() { return *this; }
      operator InvalidValue*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InvalidValue *_downcast( CORBA::Exception *ex );
      static const InvalidValue *_downcast( const CORBA::Exception *ex );
    };


    typedef InvalidValue InvalidValue_catch;






    struct TypeMismatch : public CORBA::UserException {
# 93 "../include/mico/dynany.h"
      TypeMismatch *operator->() { return this; }
      TypeMismatch& operator*() { return *this; }
      operator TypeMismatch*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static TypeMismatch *_downcast( CORBA::Exception *ex );
      static const TypeMismatch *_downcast( const CORBA::Exception *ex );
    };


    typedef TypeMismatch TypeMismatch_catch;






    virtual CORBA::TypeCode_ptr type() = 0;
    virtual void assign( DynAny_ptr dyn_any ) = 0;
    virtual void from_any( const CORBA::Any& value ) = 0;
    virtual CORBA::Any* to_any() = 0;
    virtual CORBA::Boolean equal( DynAny_ptr dyn_any ) = 0;
    virtual void destroy() = 0;
    virtual DynAny_ptr copy() = 0;
    virtual void insert_boolean( CORBA::Boolean value ) = 0;
    virtual void insert_octet( CORBA::Octet value ) = 0;
    virtual void insert_char( CORBA::Char value ) = 0;
    virtual void insert_short( CORBA::Short value ) = 0;
    virtual void insert_ushort( CORBA::UShort value ) = 0;
    virtual void insert_long( CORBA::Long value ) = 0;
    virtual void insert_ulong( CORBA::ULong value ) = 0;
    virtual void insert_float( CORBA::Float value ) = 0;
    virtual void insert_double( CORBA::Double value ) = 0;
    virtual void insert_string( const char* value ) = 0;
    virtual void insert_reference( CORBA::Object_ptr value ) = 0;
    virtual void insert_typecode( CORBA::TypeCode_ptr value ) = 0;
    virtual void insert_longlong( CORBA::LongLong value ) = 0;
    virtual void insert_ulonglong( CORBA::ULongLong value ) = 0;
    virtual void insert_longdouble( CORBA::LongDouble value ) = 0;
    virtual void insert_wchar( CORBA::WChar value ) = 0;
    virtual void insert_wstring( const CORBA::WChar* value ) = 0;
    virtual void insert_any( const CORBA::Any& value ) = 0;
    virtual void insert_dyn_any( DynAny_ptr value ) = 0;
    virtual void insert_val( CORBA::ValueBase* value ) = 0;
    virtual CORBA::Boolean get_boolean() = 0;
    virtual CORBA::Octet get_octet() = 0;
    virtual CORBA::Char get_char() = 0;
    virtual CORBA::Short get_short() = 0;
    virtual CORBA::UShort get_ushort() = 0;
    virtual CORBA::Long get_long() = 0;
    virtual CORBA::ULong get_ulong() = 0;
    virtual CORBA::Float get_float() = 0;
    virtual CORBA::Double get_double() = 0;
    virtual char* get_string() = 0;
    virtual CORBA::Object_ptr get_reference() = 0;
    virtual CORBA::TypeCode_ptr get_typecode() = 0;
    virtual CORBA::LongLong get_longlong() = 0;
    virtual CORBA::ULongLong get_ulonglong() = 0;
    virtual CORBA::LongDouble get_longdouble() = 0;
    virtual CORBA::WChar get_wchar() = 0;
    virtual CORBA::WChar* get_wstring() = 0;
    virtual CORBA::Any* get_any() = 0;
    virtual DynAny_ptr get_dyn_any() = 0;
    virtual CORBA::ValueBase* get_val() = 0;
    virtual CORBA::Boolean seek( CORBA::Long index ) = 0;
    virtual void rewind() = 0;
    virtual CORBA::Boolean next() = 0;
    virtual CORBA::ULong component_count() = 0;
    virtual DynAny_ptr current_component() = 0;
    virtual void insert_abstract( CORBA::AbstractBase * value ) = 0;
    virtual CORBA::AbstractBase * get_abstract() = 0;

  protected:
    DynAny() {};
  private:
    DynAny( const DynAny& );
    void operator=( const DynAny& );
};


class DynBasic;
typedef DynBasic *DynBasic_ptr;
typedef DynBasic_ptr DynBasicRef;
typedef ObjVar<DynBasic> DynBasic_var;
typedef ObjOut<DynBasic> DynBasic_out;



class DynBasic :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynBasic();


    typedef DynBasic_ptr _ptr_type;
    typedef DynBasic_var _var_type;


    static DynBasic_ptr _narrow( CORBA::Object_ptr obj );
    static DynBasic_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynBasic_ptr _duplicate( DynBasic_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynBasic_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    DynBasic() {};
  private:
    DynBasic( const DynBasic& );
    void operator=( const DynBasic& );
};


class DynFixed;
typedef DynFixed *DynFixed_ptr;
typedef DynFixed_ptr DynFixedRef;
typedef ObjVar<DynFixed> DynFixed_var;
typedef ObjOut<DynFixed> DynFixed_out;



class DynFixed :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynFixed();


    typedef DynFixed_ptr _ptr_type;
    typedef DynFixed_var _var_type;


    static DynFixed_ptr _narrow( CORBA::Object_ptr obj );
    static DynFixed_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynFixed_ptr _duplicate( DynFixed_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynFixed_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* get_value() = 0;
    virtual void set_value( const char* val ) = 0;

  protected:
    DynFixed() {};
  private:
    DynFixed( const DynFixed& );
    void operator=( const DynFixed& );
};


class DynEnum;
typedef DynEnum *DynEnum_ptr;
typedef DynEnum_ptr DynEnumRef;
typedef ObjVar<DynEnum> DynEnum_var;
typedef ObjOut<DynEnum> DynEnum_out;



class DynEnum :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynEnum();


    typedef DynEnum_ptr _ptr_type;
    typedef DynEnum_var _var_type;


    static DynEnum_ptr _narrow( CORBA::Object_ptr obj );
    static DynEnum_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynEnum_ptr _duplicate( DynEnum_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynEnum_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* get_as_string() = 0;
    virtual void set_as_string( const char* value ) = 0;
    virtual CORBA::ULong get_as_ulong() = 0;
    virtual void set_as_ulong( CORBA::ULong value ) = 0;

  protected:
    DynEnum() {};
  private:
    DynEnum( const DynEnum& );
    void operator=( const DynEnum& );
};


typedef char* FieldName;
typedef CORBA::String_var FieldName_var;
typedef CORBA::String_out FieldName_out;

struct NameValuePair;
typedef TVarVar<NameValuePair> NameValuePair_var;
typedef TVarOut<NameValuePair> NameValuePair_out;

struct NameValuePair {

  typedef NameValuePair_var _var_type;
# 334 "../include/mico/dynany.h"
  FieldName_var id;
  CORBA::Any value;
};

typedef SequenceTmpl<NameValuePair,0> NameValuePairSeq;



typedef TSeqVar<SequenceTmpl<NameValuePair,0> > NameValuePairSeq_var;
typedef TSeqOut<SequenceTmpl<NameValuePair,0> > NameValuePairSeq_out;

struct NameDynAnyPair;
typedef TVarVar<NameDynAnyPair> NameDynAnyPair_var;
typedef TVarOut<NameDynAnyPair> NameDynAnyPair_out;

struct NameDynAnyPair {

  typedef NameDynAnyPair_var _var_type;
# 360 "../include/mico/dynany.h"
  FieldName_var id;
  DynAny_var value;
};

typedef SequenceTmpl<NameDynAnyPair,0> NameDynAnyPairSeq;



typedef TSeqVar<SequenceTmpl<NameDynAnyPair,0> > NameDynAnyPairSeq_var;
typedef TSeqOut<SequenceTmpl<NameDynAnyPair,0> > NameDynAnyPairSeq_out;

class DynStruct;
typedef DynStruct *DynStruct_ptr;
typedef DynStruct_ptr DynStructRef;
typedef ObjVar<DynStruct> DynStruct_var;
typedef ObjOut<DynStruct> DynStruct_out;



class DynStruct :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynStruct();


    typedef DynStruct_ptr _ptr_type;
    typedef DynStruct_var _var_type;


    static DynStruct_ptr _narrow( CORBA::Object_ptr obj );
    static DynStruct_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynStruct_ptr _duplicate( DynStruct_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynStruct_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* current_member_name() = 0;
    virtual CORBA::TCKind current_member_kind() = 0;
    virtual NameValuePairSeq* get_members() = 0;
    virtual void set_members( const NameValuePairSeq& value ) = 0;
    virtual NameDynAnyPairSeq* get_members_as_dyn_any() = 0;
    virtual void set_members_as_dyn_any( const NameDynAnyPairSeq& value ) = 0;

  protected:
    DynStruct() {};
  private:
    DynStruct( const DynStruct& );
    void operator=( const DynStruct& );
};


class DynUnion;
typedef DynUnion *DynUnion_ptr;
typedef DynUnion_ptr DynUnionRef;
typedef ObjVar<DynUnion> DynUnion_var;
typedef ObjOut<DynUnion> DynUnion_out;



class DynUnion :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynUnion();


    typedef DynUnion_ptr _ptr_type;
    typedef DynUnion_var _var_type;


    static DynUnion_ptr _narrow( CORBA::Object_ptr obj );
    static DynUnion_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynUnion_ptr _duplicate( DynUnion_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynUnion_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual DynAny_ptr get_discriminator() = 0;
    virtual void set_discriminator( DynAny_ptr d ) = 0;
    virtual void set_to_default_member() = 0;
    virtual void set_to_no_active_member() = 0;
    virtual CORBA::Boolean has_no_active_member() = 0;
    virtual CORBA::TCKind discriminator_kind() = 0;
    virtual DynAny_ptr member() = 0;
    virtual char* member_name() = 0;
    virtual CORBA::TCKind member_kind() = 0;

  protected:
    DynUnion() {};
  private:
    DynUnion( const DynUnion& );
    void operator=( const DynUnion& );
};


typedef SequenceTmpl<CORBA::Any,0> AnySeq;



typedef TSeqVar<SequenceTmpl<CORBA::Any,0> > AnySeq_var;
typedef TSeqOut<SequenceTmpl<CORBA::Any,0> > AnySeq_out;

typedef IfaceSequenceTmpl<DynAny_var,DynAny_ptr> DynAnySeq;



typedef TSeqVar<IfaceSequenceTmpl<DynAny_var,DynAny_ptr> > DynAnySeq_var;
typedef TSeqOut<IfaceSequenceTmpl<DynAny_var,DynAny_ptr> > DynAnySeq_out;

class DynSequence;
typedef DynSequence *DynSequence_ptr;
typedef DynSequence_ptr DynSequenceRef;
typedef ObjVar<DynSequence> DynSequence_var;
typedef ObjOut<DynSequence> DynSequence_out;



class DynSequence :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynSequence();


    typedef DynSequence_ptr _ptr_type;
    typedef DynSequence_var _var_type;


    static DynSequence_ptr _narrow( CORBA::Object_ptr obj );
    static DynSequence_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynSequence_ptr _duplicate( DynSequence_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynSequence_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::ULong get_length() = 0;
    virtual void set_length( CORBA::ULong len ) = 0;
    virtual AnySeq* get_elements() = 0;
    virtual void set_elements( const AnySeq& value ) = 0;
    virtual DynAnySeq* get_elements_as_dyn_any() = 0;
    virtual void set_elements_as_dyn_any( const DynAnySeq& value ) = 0;

  protected:
    DynSequence() {};
  private:
    DynSequence( const DynSequence& );
    void operator=( const DynSequence& );
};


class DynArray;
typedef DynArray *DynArray_ptr;
typedef DynArray_ptr DynArrayRef;
typedef ObjVar<DynArray> DynArray_var;
typedef ObjOut<DynArray> DynArray_out;



class DynArray :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynArray();


    typedef DynArray_ptr _ptr_type;
    typedef DynArray_var _var_type;


    static DynArray_ptr _narrow( CORBA::Object_ptr obj );
    static DynArray_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynArray_ptr _duplicate( DynArray_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynArray_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual AnySeq* get_elements() = 0;
    virtual void set_elements( const AnySeq& value ) = 0;
    virtual DynAnySeq* get_elements_as_dyn_any() = 0;
    virtual void set_elements_as_dyn_any( const DynAnySeq& value ) = 0;

  protected:
    DynArray() {};
  private:
    DynArray( const DynArray& );
    void operator=( const DynArray& );
};


class DynValueCommon;
typedef DynValueCommon *DynValueCommon_ptr;
typedef DynValueCommon_ptr DynValueCommonRef;
typedef ObjVar<DynValueCommon> DynValueCommon_var;
typedef ObjOut<DynValueCommon> DynValueCommon_out;



class DynValueCommon :
  virtual public ::DynamicAny::DynAny
{
  public:
    typedef ::DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    virtual ~DynValueCommon();


    typedef DynValueCommon_ptr _ptr_type;
    typedef DynValueCommon_var _var_type;


    static DynValueCommon_ptr _narrow( CORBA::Object_ptr obj );
    static DynValueCommon_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynValueCommon_ptr _duplicate( DynValueCommon_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynValueCommon_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean is_null() = 0;
    virtual void set_to_null() = 0;
    virtual void set_to_value() = 0;

  protected:
    DynValueCommon() {};
  private:
    DynValueCommon( const DynValueCommon& );
    void operator=( const DynValueCommon& );
};


class DynValue;
typedef DynValue *DynValue_ptr;
typedef DynValue_ptr DynValueRef;
typedef ObjVar<DynValue> DynValue_var;
typedef ObjOut<DynValue> DynValue_out;



class DynValue :
  virtual public ::DynamicAny::DynValueCommon
{
  public:
    typedef ::DynamicAny::DynValueCommon _VCHACK__DynamicAny__DynValueCommon;
    virtual ~DynValue();


    typedef DynValue_ptr _ptr_type;
    typedef DynValue_var _var_type;


    static DynValue_ptr _narrow( CORBA::Object_ptr obj );
    static DynValue_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynValue_ptr _duplicate( DynValue_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynValue_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* current_member_name() = 0;
    virtual CORBA::TCKind current_member_kind() = 0;
    virtual NameValuePairSeq* get_members() = 0;
    virtual void set_members( const NameValuePairSeq& values ) = 0;
    virtual NameDynAnyPairSeq* get_members_as_dyn_any() = 0;
    virtual void set_members_as_dyn_any( const NameDynAnyPairSeq& values ) = 0;

  protected:
    DynValue() {};
  private:
    DynValue( const DynValue& );
    void operator=( const DynValue& );
};


class DynValueBox;
typedef DynValueBox *DynValueBox_ptr;
typedef DynValueBox_ptr DynValueBoxRef;
typedef ObjVar<DynValueBox> DynValueBox_var;
typedef ObjOut<DynValueBox> DynValueBox_out;



class DynValueBox :
  virtual public ::DynamicAny::DynValueCommon
{
  public:
    typedef ::DynamicAny::DynValueCommon _VCHACK__DynamicAny__DynValueCommon;
    virtual ~DynValueBox();


    typedef DynValueBox_ptr _ptr_type;
    typedef DynValueBox_var _var_type;


    static DynValueBox_ptr _narrow( CORBA::Object_ptr obj );
    static DynValueBox_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynValueBox_ptr _duplicate( DynValueBox_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynValueBox_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Any* get_boxed_value() = 0;
    virtual void set_boxed_value( const CORBA::Any& boxed ) = 0;
    virtual DynAny_ptr get_boxed_value_as_dyn_any() = 0;
    virtual void set_boxed_value_as_dyn_any( DynAny_ptr boxed ) = 0;

  protected:
    DynValueBox() {};
  private:
    DynValueBox( const DynValueBox& );
    void operator=( const DynValueBox& );
};


class DynAnyFactory;
typedef DynAnyFactory *DynAnyFactory_ptr;
typedef DynAnyFactory_ptr DynAnyFactoryRef;
typedef ObjVar<DynAnyFactory> DynAnyFactory_var;
typedef ObjOut<DynAnyFactory> DynAnyFactory_out;



class DynAnyFactory :
  virtual public CORBA::LocalObject
{
  public:
    virtual ~DynAnyFactory();


    typedef DynAnyFactory_ptr _ptr_type;
    typedef DynAnyFactory_var _var_type;


    static DynAnyFactory_ptr _narrow( CORBA::Object_ptr obj );
    static DynAnyFactory_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static DynAnyFactory_ptr _duplicate( DynAnyFactory_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static DynAnyFactory_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct InconsistentTypeCode : public CORBA::UserException {
# 775 "../include/mico/dynany.h"
      InconsistentTypeCode *operator->() { return this; }
      InconsistentTypeCode& operator*() { return *this; }
      operator InconsistentTypeCode*() { return this; }


      void _throwit() const;
      const char *_repoid() const;
      void _encode( CORBA::DataEncoder &en ) const;
      void _encode_any( CORBA::Any &a ) const;
      CORBA::Exception *_clone() const;
      static InconsistentTypeCode *_downcast( CORBA::Exception *ex );
      static const InconsistentTypeCode *_downcast( const CORBA::Exception *ex );
    };


    typedef InconsistentTypeCode InconsistentTypeCode_catch;






    virtual DynAny_ptr create_dyn_any( const CORBA::Any& value ) = 0;
    virtual DynAny_ptr create_dyn_any_from_type_code( CORBA::TypeCode_ptr type ) = 0;

  protected:
    DynAnyFactory() {};
  private:
    DynAnyFactory( const DynAnyFactory& );
    void operator=( const DynAnyFactory& );
};


}




namespace POA_DynamicAny {


}




extern CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAny_InvalidValue;

extern CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAny_TypeMismatch;

extern CORBA::StaticTypeInfo *_marshaller_DynamicAny_NameValuePair;

extern CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode;

extern CORBA::StaticTypeInfo *_marshaller__seq_DynamicAny_NameValuePair;
# 235 "../include/CORBA.h" 2



# 1 "../include/mico/intercept.h" 1
# 32 "../include/mico/intercept.h"
namespace Interceptor {
    enum Status {
        INVOKE_CONTINUE = 0,
        INVOKE_ABORT,
        INVOKE_RETRY,
        INVOKE_BREAK
    };


    class Root;
    typedef Root *Root_ptr;
    typedef ObjVar<Root> Root_var;

    class Root : public CORBA::ServerlessObject {
    public:
        typedef CORBA::ULong Priority;


        enum {
            LowestPriority = 0,
            HighestPriority = 0x7fffffff
        };
    private:
        Priority _prio;
        CORBA::Boolean _is_active;
    public:
        Root ();
        Root (Priority p);
        virtual ~Root ();

        virtual const char *_repoid() const;
        static Root_ptr _nil ()
        {
            return 0;
        }
        static Root_ptr _duplicate (Root_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static Root_ptr _narrow (Root_ptr);

        Priority prio();

        virtual void activate (Priority p);
        virtual void deactivate ();
        CORBA::Boolean is_active ();
    };


    class Context;
    typedef Context *Context_ptr;
    typedef ObjVar<Context> Context_var;
    typedef ObjOut<Context> Context_out;

    class Context : public CORBA::ServerlessObject {
    public:
        Context ();
        virtual ~Context ();

        virtual const char *_repoid() const;
        static Context_ptr _nil ()
        {
            return 0;
        }
        static Context_ptr _duplicate (Context_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static Context_ptr _narrow (Context_ptr);

        void destroy ();
    };


    typedef CORBA::IOP::ServiceID ServiceID;
    typedef SequenceTmpl<CORBA::Octet,3> ContextData;
    typedef TSeqVar<ContextData> ContextData_var;


    class LWRootRequest;
    typedef LWRootRequest *LWRootRequest_ptr;
    typedef ObjVar<LWRootRequest> LWRootRequest_var;
    typedef ObjOut<LWRootRequest> LWRootRequest_out;

    class LWRootRequest : public CORBA::ServerlessObject {
    private:
        typedef map<Root_ptr, Context_var, less<Root_ptr> > CtxMap;
        CtxMap _ctxs;
        CORBA::IOP::ServiceContextList &_svc;
        CORBA::String_var &_op;
        CORBA::Object_var &_obj;
    public:
        LWRootRequest (CORBA::Object_var &obj,
                       CORBA::String_var &op,
                       CORBA::IOP::ServiceContextList &svc);
        virtual ~LWRootRequest ();

        virtual const char *_repoid() const;
        static LWRootRequest_ptr _nil ()
        {
            return 0;
        }
        static LWRootRequest_ptr _duplicate (LWRootRequest_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static LWRootRequest_ptr _narrow (LWRootRequest_ptr);

        CORBA::Object_ptr target();
        void target (CORBA::Object_ptr);
        CORBA::Identifier operation();
        void operation (const CORBA::Identifier);

        void set_service_context (ServiceID id,
                                  CORBA::Long flags,
                                  const ContextData &d);
        ContextData *get_service_context (ServiceID id,
                                          CORBA::Long flags);
        void remove_service_context (ServiceID id);
        CORBA::Boolean has_service_context (ServiceID id);

        void set_context (Root_ptr interceptor, Context_ptr ctx);
        Context_ptr get_context (Root_ptr interceptor);
    };


    class LWRequest;
    typedef LWRequest *LWRequest_ptr;
    typedef ObjVar<LWRequest> LWRequest_var;
    typedef ObjOut<LWRequest> LWRequest_out;

    class LWRequest : public LWRootRequest {
        CORBA::Request_ptr _req;
    public:
        LWRequest (CORBA::Object_var &obj,
                   CORBA::String_var &op,
                   CORBA::IOP::ServiceContextList &svc,
                   CORBA::Request_ptr req);
        virtual ~LWRequest ();

        virtual const char *_repoid() const;
        static LWRequest_ptr _nil ()
        {
            return 0;
        }
        static LWRequest_ptr _duplicate (LWRequest_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static LWRequest_ptr _narrow (LWRootRequest_ptr);

        CORBA::Request_ptr request ();
    };


    class LWServerRequest;
    typedef LWServerRequest *LWServerRequest_ptr;
    typedef ObjVar<LWServerRequest> LWServerRequest_var;
    typedef ObjOut<LWServerRequest> LWServerRequest_out;

    class LWServerRequest : public LWRootRequest {
        CORBA::ServerRequest_ptr _req;
        CORBA::Object_var _obj;
        CORBA::String_var _op;
    public:
        LWServerRequest (CORBA::Object_ptr obj,
                         const char *op,
                         CORBA::IOP::ServiceContextList &svc,
                         CORBA::ServerRequest_ptr req);
        virtual ~LWServerRequest ();

        virtual const char *_repoid() const;
        static LWServerRequest_ptr _nil ()
        {
            return 0;
        }
        static LWServerRequest_ptr _duplicate (LWServerRequest_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static LWServerRequest_ptr _narrow (LWRootRequest_ptr);

        CORBA::ServerRequest_ptr request ();
    };


    class ClientInterceptor;
    typedef ClientInterceptor *ClientInterceptor_ptr;
    typedef ObjVar<ClientInterceptor> ClientInterceptor_var;
    typedef ObjOut<ClientInterceptor> ClientInterceptor_out;

    class ClientInterceptor : public Root {
        static list<ClientInterceptor_ptr> *_interceptors;
        static list<ClientInterceptor_ptr> &_ics ();
    public:
        ClientInterceptor ();
        ClientInterceptor (Priority p);
        virtual ~ClientInterceptor ();

        virtual const char *_repoid() const;
        static ClientInterceptor_ptr _nil ()
        {
            return 0;
        }
        static ClientInterceptor_ptr _duplicate (ClientInterceptor_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static ClientInterceptor_ptr _narrow (Root_ptr);

        virtual Status initialize_request (LWRequest_ptr req,
                                           CORBA::Environment_ptr env);
        virtual Status after_marshal (LWRequest_ptr req,
                                      CORBA::Environment_ptr env);
        virtual Status output_message (CORBA::Buffer *buf,
                                       CORBA::Environment_ptr env);
        virtual Status input_message (CORBA::Buffer *buf,
                                      CORBA::Environment_ptr env);
        virtual Status before_unmarshal (LWRequest_ptr req,
                                         CORBA::Environment_ptr env);
        virtual Status finish_request (LWRequest_ptr req,
                                       CORBA::Environment_ptr env);


        void activate (Priority p);
        void deactivate ();

        typedef Status (ClientInterceptor::*InterceptorMethod1) (
            LWRequest_ptr,
            CORBA::Environment_ptr);

        typedef Status (ClientInterceptor::*InterceptorMethod2) (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec (
            LWRequest_ptr,
            CORBA::Environment_ptr,
            InterceptorMethod1 m);

        static CORBA::Boolean _exec (
            CORBA::Buffer *,
            CORBA::Environment_ptr,
            InterceptorMethod2 m);

        static CORBA::Boolean _exec_initialize_request (
            LWRequest_ptr,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_after_marshal (
            LWRequest_ptr,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_output_message (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_input_message (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_before_unmarshal (
            LWRequest_ptr,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_finish_request (
            LWRequest_ptr,
            CORBA::Environment_ptr);

        static LWRequest_ptr _create_request (
            CORBA::Object_var &obj,
            CORBA::String_var &op,
            CORBA::IOP::ServiceContextList &svc,
            CORBA::Request_ptr req);

        static CORBA::Boolean _idle ()
        { return _ics().size() == 0; }
    };


    class ServerInterceptor;
    typedef ServerInterceptor *ServerInterceptor_ptr;
    typedef ObjVar<ServerInterceptor> ServerInterceptor_var;
    typedef ObjOut<ServerInterceptor> ServerInterceptor_out;

    class ServerInterceptor : public Root {
        static list<ServerInterceptor_ptr> *_interceptors;
        static list<ServerInterceptor_ptr> &_ics ();
    public:
        ServerInterceptor ();
        ServerInterceptor (Priority p);
        virtual ~ServerInterceptor ();

        virtual const char *_repoid() const;
        static ServerInterceptor_ptr _nil ()
        {
            return 0;
        }
        static ServerInterceptor_ptr _duplicate (ServerInterceptor_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static ServerInterceptor_ptr _narrow (Root_ptr);

        virtual Status input_message (CORBA::Buffer *buf,
                                      CORBA::Environment_ptr env);
        virtual Status initialize_request (LWServerRequest_ptr req,
                                           CORBA::Environment_ptr env);
        virtual Status after_unmarshal (LWServerRequest_ptr req,
                                        CORBA::Environment_ptr env);
        virtual Status before_marshal (LWServerRequest_ptr req,
                                       CORBA::Environment_ptr env);
        virtual Status finish_request (LWServerRequest_ptr req,
                                       CORBA::Environment_ptr env);
        virtual Status output_message (CORBA::Buffer *buf,
                                       CORBA::Environment_ptr env);


        void activate (Priority p);
        void deactivate ();

        typedef Status (ServerInterceptor::*InterceptorMethod1) (
            LWServerRequest_ptr,
            CORBA::Environment_ptr);

        typedef Status (ServerInterceptor::*InterceptorMethod2) (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec (
            LWServerRequest_ptr,
            CORBA::Environment_ptr,
            InterceptorMethod1 m);

        static CORBA::Boolean _exec (
            CORBA::Buffer *,
            CORBA::Environment_ptr,
            InterceptorMethod2 m);

        static CORBA::Boolean _exec_input_message (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static CORBA::Boolean _exec_initialize_request (
            LWServerRequest_ptr,
            CORBA::Environment_ptr env);

        static CORBA::Boolean _exec_after_unmarshal (
            LWServerRequest_ptr,
            CORBA::Environment_ptr env);

        static CORBA::Boolean _exec_before_marshal (
            LWServerRequest_ptr,
            CORBA::Environment_ptr env);

        static CORBA::Boolean _exec_finish_request (
            LWServerRequest_ptr,
            CORBA::Environment_ptr env);

        static CORBA::Boolean _exec_output_message (
            CORBA::Buffer *,
            CORBA::Environment_ptr);

        static LWServerRequest_ptr _create_request (
            CORBA::Object_ptr obj,
            const char *op,
            CORBA::IOP::ServiceContextList &svc,
            CORBA::ServerRequest_ptr req);

        static CORBA::Boolean _idle ()
        { return _ics().size() == 0; }
    };


    class InitInterceptor;
    typedef InitInterceptor *InitInterceptor_ptr;
    typedef ObjVar<InitInterceptor> InitInterceptor_var;
    typedef ObjOut<InitInterceptor> InitInterceptor_out;

    class InitInterceptor : public Root {
        static list<InitInterceptor_ptr> *_interceptors;
        static list<InitInterceptor_ptr> &_ics ();
    public:
        InitInterceptor ();
        InitInterceptor (Priority p);
        virtual ~InitInterceptor ();

        virtual const char *_repoid() const;
        static InitInterceptor_ptr _nil ()
        {
            return 0;
        }
        static InitInterceptor_ptr _duplicate (InitInterceptor_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static InitInterceptor_ptr _narrow (Root_ptr);

        virtual Status initialize (CORBA::ORB_ptr orb,
                                   const char *id,
                                   int &argc, char *argv[]);


        void activate (Priority p);
        void deactivate ();

        static CORBA::Boolean _exec_initialize (CORBA::ORB_ptr orb,
                                                const char *id,
                                                int &argc, char *argv[]);
    };


    class BOAInterceptor;
    typedef BOAInterceptor *BOAInterceptor_ptr;
    typedef ObjVar<BOAInterceptor> BOAInterceptor_var;
    typedef ObjOut<BOAInterceptor> BOAInterceptor_out;

    class BOAInterceptor : public Root {
        static list<BOAInterceptor_ptr> *_interceptors;
        static list<BOAInterceptor_ptr> &_ics ();
    public:
        BOAInterceptor ();
        BOAInterceptor (Priority p);
        virtual ~BOAInterceptor ();

        virtual const char *_repoid() const;
        static BOAInterceptor_ptr _nil ()
        {
            return 0;
        }
        static BOAInterceptor_ptr _duplicate (BOAInterceptor_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static BOAInterceptor_ptr _narrow (Root_ptr);

        virtual Status restore (CORBA::Object_ptr obj);
        virtual Status create (CORBA::Object_ptr obj);
        virtual Status bind (const char *repoid,
                             const CORBA::ORB::ObjectTag &);


        void activate (Priority p);
        void deactivate ();

        static CORBA::Boolean _exec_restore (CORBA::Object_ptr obj);
        static CORBA::Boolean _exec_create (CORBA::Object_ptr obj);
        static CORBA::Boolean _exec_bind (const char *repoid,
                                          const CORBA::ORB::ObjectTag &);
    };

    class ConnInterceptor;
    typedef ConnInterceptor *ConnInterceptor_ptr;
    typedef ObjVar<ConnInterceptor> ConnInterceptor_var;
    typedef ObjOut<ConnInterceptor> ConnInterceptor_out;

    class ConnInterceptor : public Root {
        static list<ConnInterceptor_ptr> *_interceptors;
        static list<ConnInterceptor_ptr> &_ics ();
    public:
        ConnInterceptor ();
        ConnInterceptor (Priority p);
        virtual ~ConnInterceptor ();

        virtual const char *_repoid() const;
        static ConnInterceptor_ptr _nil ()
        {
            return 0;
        }
        static ConnInterceptor_ptr _duplicate (ConnInterceptor_ptr o)
        {
            if (o)
                o->_ref();
            return o;
        }
        static ConnInterceptor_ptr _narrow (Root_ptr);

        virtual Status client_connect (const char *addr);
        virtual Status client_disconnect (const char *addr);


        void activate (Priority p);
        void deactivate ();

        static CORBA::Boolean _exec_client_connect (const char *addr);
        static CORBA::Boolean _exec_client_disconnect (const char *addr);
    };
}
# 239 "../include/CORBA.h" 2


# 1 "../include/mico/operators.h" 1
# 31 "../include/mico/operators.h"
static inline void
operator<<= (CORBA::Any_var &a, CORBA::Short v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Long v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::LongLong v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::UShort v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::ULong v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::ULongLong v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Float v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Double v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::LongDouble v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, const CORBA::Any & v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any *v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, const CORBA::Exception & v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Exception *v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, const char * v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, const wchar_t * v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_boolean v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_octet v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_char v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_wchar v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_string v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_wstring v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_fixed v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Any::from_object v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Object_ptr v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Object_ptr *v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::TypeCode_ptr v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::TypeCode_ptr *v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Context_ptr v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Context_ptr *v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Principal_ptr v)
{
    a.inout() <<= v;
}

static inline void
operator<<= (CORBA::Any_var &a, CORBA::Principal_ptr *v)
{
    a.inout() <<= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Short &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Long &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::LongLong &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::UShort &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::ULong &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::ULongLong &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Float &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Double &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::LongDouble &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, const CORBA::Any *&v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, const char * &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, const wchar_t * &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_boolean v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_octet v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_char v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_wchar v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_string v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_wstring v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_object v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_abstract_base v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Any::to_fixed v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Object_ptr &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::TypeCode_ptr &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Context_ptr &v)
{
    return a.in() >>= v;
}

static inline CORBA::Boolean
operator>>= (const CORBA::Any_var &a, CORBA::Principal_ptr &v)
{
    return a.in() >>= v;
}
# 377 "../include/mico/operators.h"
# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
void operator<<= (CORBA::Any &, const CORBA::UNKNOWN &); void operator<<= (CORBA::Any &, CORBA::UNKNOWN *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UNKNOWN &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::UNKNOWN *&);
void operator<<= (CORBA::Any &, const CORBA::BAD_PARAM &); void operator<<= (CORBA::Any &, CORBA::BAD_PARAM *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_PARAM &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_PARAM *&);
void operator<<= (CORBA::Any &, const CORBA::NO_MEMORY &); void operator<<= (CORBA::Any &, CORBA::NO_MEMORY *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_MEMORY &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_MEMORY *&);
void operator<<= (CORBA::Any &, const CORBA::IMP_LIMIT &); void operator<<= (CORBA::Any &, CORBA::IMP_LIMIT *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IMP_LIMIT &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IMP_LIMIT *&);
void operator<<= (CORBA::Any &, const CORBA::COMM_FAILURE &); void operator<<= (CORBA::Any &, CORBA::COMM_FAILURE *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::COMM_FAILURE &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::COMM_FAILURE *&);
void operator<<= (CORBA::Any &, const CORBA::INV_OBJREF &); void operator<<= (CORBA::Any &, CORBA::INV_OBJREF *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_OBJREF &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_OBJREF *&);
void operator<<= (CORBA::Any &, const CORBA::NO_PERMISSION &); void operator<<= (CORBA::Any &, CORBA::NO_PERMISSION *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_PERMISSION &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_PERMISSION *&);
void operator<<= (CORBA::Any &, const CORBA::INTERNAL &); void operator<<= (CORBA::Any &, CORBA::INTERNAL *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INTERNAL &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INTERNAL *&);
void operator<<= (CORBA::Any &, const CORBA::MARSHAL &); void operator<<= (CORBA::Any &, CORBA::MARSHAL *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::MARSHAL &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::MARSHAL *&);
void operator<<= (CORBA::Any &, const CORBA::INITIALIZE &); void operator<<= (CORBA::Any &, CORBA::INITIALIZE *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INITIALIZE &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INITIALIZE *&);
void operator<<= (CORBA::Any &, const CORBA::NO_IMPLEMENT &); void operator<<= (CORBA::Any &, CORBA::NO_IMPLEMENT *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_IMPLEMENT &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_IMPLEMENT *&);
void operator<<= (CORBA::Any &, const CORBA::BAD_TYPECODE &); void operator<<= (CORBA::Any &, CORBA::BAD_TYPECODE *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_TYPECODE &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_TYPECODE *&);
void operator<<= (CORBA::Any &, const CORBA::BAD_OPERATION &); void operator<<= (CORBA::Any &, CORBA::BAD_OPERATION *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_OPERATION &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_OPERATION *&);
void operator<<= (CORBA::Any &, const CORBA::NO_RESOURCES &); void operator<<= (CORBA::Any &, CORBA::NO_RESOURCES *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_RESOURCES &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_RESOURCES *&);
void operator<<= (CORBA::Any &, const CORBA::NO_RESPONSE &); void operator<<= (CORBA::Any &, CORBA::NO_RESPONSE *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_RESPONSE &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::NO_RESPONSE *&);
void operator<<= (CORBA::Any &, const CORBA::PERSIST_STORE &); void operator<<= (CORBA::Any &, CORBA::PERSIST_STORE *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PERSIST_STORE &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PERSIST_STORE *&);
void operator<<= (CORBA::Any &, const CORBA::BAD_INV_ORDER &); void operator<<= (CORBA::Any &, CORBA::BAD_INV_ORDER *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_INV_ORDER &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_INV_ORDER *&);
void operator<<= (CORBA::Any &, const CORBA::TRANSIENT &); void operator<<= (CORBA::Any &, CORBA::TRANSIENT *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSIENT &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSIENT *&);
void operator<<= (CORBA::Any &, const CORBA::FREE_MEM &); void operator<<= (CORBA::Any &, CORBA::FREE_MEM *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::FREE_MEM &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::FREE_MEM *&);
void operator<<= (CORBA::Any &, const CORBA::INV_IDENT &); void operator<<= (CORBA::Any &, CORBA::INV_IDENT *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_IDENT &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_IDENT *&);
void operator<<= (CORBA::Any &, const CORBA::INV_FLAG &); void operator<<= (CORBA::Any &, CORBA::INV_FLAG *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_FLAG &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_FLAG *&);
void operator<<= (CORBA::Any &, const CORBA::INTF_REPOS &); void operator<<= (CORBA::Any &, CORBA::INTF_REPOS *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INTF_REPOS &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INTF_REPOS *&);
void operator<<= (CORBA::Any &, const CORBA::BAD_CONTEXT &); void operator<<= (CORBA::Any &, CORBA::BAD_CONTEXT *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_CONTEXT &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::BAD_CONTEXT *&);
void operator<<= (CORBA::Any &, const CORBA::OBJ_ADAPTER &); void operator<<= (CORBA::Any &, CORBA::OBJ_ADAPTER *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OBJ_ADAPTER &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OBJ_ADAPTER *&);
void operator<<= (CORBA::Any &, const CORBA::DATA_CONVERSION &); void operator<<= (CORBA::Any &, CORBA::DATA_CONVERSION *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DATA_CONVERSION &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DATA_CONVERSION *&);
void operator<<= (CORBA::Any &, const CORBA::OBJECT_NOT_EXIST &); void operator<<= (CORBA::Any &, CORBA::OBJECT_NOT_EXIST *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OBJECT_NOT_EXIST &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::OBJECT_NOT_EXIST *&);
void operator<<= (CORBA::Any &, const CORBA::TRANSACTION_REQUIRED &); void operator<<= (CORBA::Any &, CORBA::TRANSACTION_REQUIRED *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSACTION_REQUIRED &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSACTION_REQUIRED *&);
void operator<<= (CORBA::Any &, const CORBA::TRANSACTION_ROLLEDBACK &); void operator<<= (CORBA::Any &, CORBA::TRANSACTION_ROLLEDBACK *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSACTION_ROLLEDBACK &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TRANSACTION_ROLLEDBACK *&);
void operator<<= (CORBA::Any &, const CORBA::INVALID_TRANSACTION &); void operator<<= (CORBA::Any &, CORBA::INVALID_TRANSACTION *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INVALID_TRANSACTION &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INVALID_TRANSACTION *&);
void operator<<= (CORBA::Any &, const CORBA::INV_POLICY &); void operator<<= (CORBA::Any &, CORBA::INV_POLICY *); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_POLICY &); CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::INV_POLICY *&);
# 378 "../include/mico/operators.h" 2







static inline ostream &
operator<< (ostream &os, const CORBA::Exception *ex)
{
    ex->_print (os);
    return os;
}

static inline ostream &
operator<< (ostream &os, const CORBA::Exception &ex)
{
    ex._print (os);
    return os;
}

static inline ostream &
operator<< (ostream &os, CORBA::String_var &svar)
{
    return os << svar.in();
}

static inline istream &
operator>> (istream &is, CORBA::String_var &svar)
{
    string s;
    is >> s;
    svar = s.c_str();
    return is;
}
# 242 "../include/CORBA.h" 2
# 1 "../include/mico/policy2.h" 1
# 12 "../include/mico/policy2.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/policy2.h" 2



namespace MICOPolicy {





extern const CORBA::ULong TRANSPORTPREF_POLICY_TYPE;
class TransportPrefPolicy;
typedef TransportPrefPolicy *TransportPrefPolicy_ptr;
typedef TransportPrefPolicy_ptr TransportPrefPolicyRef;
typedef ObjVar<TransportPrefPolicy> TransportPrefPolicy_var;
typedef ObjOut<TransportPrefPolicy> TransportPrefPolicy_out;



class TransportPrefPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~TransportPrefPolicy();


    typedef TransportPrefPolicy_ptr _ptr_type;
    typedef TransportPrefPolicy_var _var_type;


    static TransportPrefPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static TransportPrefPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static TransportPrefPolicy_ptr _duplicate( TransportPrefPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static TransportPrefPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    typedef CORBA::ULong ProfileTag;
    typedef ProfileTag& ProfileTag_out;
    static CORBA::TypeCodeConst _tc_ProfileTag;

    typedef SequenceTmpl<ProfileTag,0> ProfileTagSeq;



    typedef TSeqVar<SequenceTmpl<ProfileTag,0> > ProfileTagSeq_var;
    typedef TSeqOut<SequenceTmpl<ProfileTag,0> > ProfileTagSeq_out;

    static CORBA::TypeCodeConst _tc_ProfileTagSeq;

    virtual ProfileTagSeq* preferences() = 0;
    virtual void preferences( const ProfileTagSeq& value ) = 0;
    virtual ProfileTagSeq* preferences_nocopy() = 0;

  protected:
    TransportPrefPolicy() {};
  private:
    TransportPrefPolicy( const TransportPrefPolicy& );
    void operator=( const TransportPrefPolicy& );
};






}





namespace BiDirPolicy {





typedef CORBA::UShort BidirectionalPolicyValue;
typedef BidirectionalPolicyValue& BidirectionalPolicyValue_out;
extern CORBA::TypeCodeConst _tc_BidirectionalPolicyValue;

extern const CORBA::UShort NORMAL;
extern const CORBA::UShort BOTH;
extern const CORBA::ULong BIDIRECTIONAL_POLICY_TYPE;
class BidirectionalPolicy;
typedef BidirectionalPolicy *BidirectionalPolicy_ptr;
typedef BidirectionalPolicy_ptr BidirectionalPolicyRef;
typedef ObjVar<BidirectionalPolicy> BidirectionalPolicy_var;
typedef ObjOut<BidirectionalPolicy> BidirectionalPolicy_out;



class BidirectionalPolicy :
  virtual public ::CORBA::Policy
{
  public:
    typedef ::CORBA::Policy _VCHACK__CORBA__Policy;
    virtual ~BidirectionalPolicy();


    typedef BidirectionalPolicy_ptr _ptr_type;
    typedef BidirectionalPolicy_var _var_type;


    static BidirectionalPolicy_ptr _narrow( CORBA::Object_ptr obj );
    static BidirectionalPolicy_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static BidirectionalPolicy_ptr _duplicate( BidirectionalPolicy_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static BidirectionalPolicy_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual BidirectionalPolicyValue value() = 0;

  protected:
    BidirectionalPolicy() {};
  private:
    BidirectionalPolicy( const BidirectionalPolicy& );
    void operator=( const BidirectionalPolicy& );
};






}
# 166 "../include/mico/policy2.h"
void operator<<=( CORBA::Any &_a, const SequenceTmpl<MICOPolicy::TransportPrefPolicy::ProfileTag,0> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl<MICOPolicy::TransportPrefPolicy::ProfileTag,0> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl<MICOPolicy::TransportPrefPolicy::ProfileTag,0> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl<MICOPolicy::TransportPrefPolicy::ProfileTag,0> *&_s );





# 1 "../include/mico/template_impl.h" 1
# 176 "../include/mico/policy2.h" 2
# 243 "../include/CORBA.h" 2


CORBA::ULong mico_string_hash (const char *, CORBA::ULong);

# 1 "../include/mico/throw.h" 1
# 27 "../include/mico/throw.h"
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stdarg.h" 1 3 4
# 28 "../include/mico/throw.h" 2
# 51 "../include/mico/throw.h"
static void
mico_throw (const CORBA::Exception &ex)
{

    (void)mico_throw;
# 86 "../include/mico/throw.h"
    ex._throwit ();



}

static void
mico_sii_throw (CORBA::StaticRequest *r, ...)
{

    (void)mico_sii_throw;


    if (r->exception()) {
        CORBA::Exception *ex = r->exception();
        CORBA::UnknownUserException *uuex =
            CORBA::UnknownUserException::_downcast (ex);
        if (uuex) {
            va_list args;
            __builtin_stdarg_start((args),r);
            CORBA::StaticTypeInfo *si;
            const char *repoid;
            while ((si = __builtin_va_arg (args, CORBA::StaticTypeInfo *))) {
                repoid = __builtin_va_arg (args, const char *);
                ((void) ((repoid) ? 0 : (__assert_fail ("repoid", "../include/mico/throw.h", 110, __PRETTY_FUNCTION__), 0)));
                if (!strcmp (uuex->_except_repoid(), repoid)) {
                    __builtin_va_end (args);
                    CORBA::StaticAny &a = uuex->exception (si);






                    mico_throw (*(CORBA::Exception*)a.value());
                }
            }
            __builtin_va_end (args);
            mico_throw (CORBA::UNKNOWN());
        } else {
            mico_throw (*ex);
        }
    }




}

inline void
CORBA::Exception::_raise ()
{
    ::mico_throw (*this);
}
# 248 "../include/CORBA.h" 2
# 1 "../include/mico/template_impl.h" 1
# 249 "../include/CORBA.h" 2
# 2 "orb_all.cc" 2
# 1 "address.cc" 1
# 25 "address.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 52 "../include/CORBA-SMALL.h"
# 1 "../include/CORBA.h" 1
# 53 "../include/CORBA-SMALL.h" 2
# 26 "address.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "address.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 30 "address.cc" 2
# 1 "../include/mico/os-net.h" 1
# 228 "../include/mico/os-net.h"
# 1 "/usr/include/strings.h" 1 3 4
# 22 "/usr/include/strings.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/strings.h" 2 3 4

# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 25 "/usr/include/strings.h" 2 3 4

extern "C" {


extern int bcmp (__const void * __s1, __const void * __s2, size_t __n) throw ();


extern void bcopy (__const void * __src, void * __dest, size_t __n) throw ();


extern void bzero (void * __s, size_t __n) throw ();



extern int ffs (int __i) throw ();


extern char *index (__const char *__s, int __c) throw ();


extern char *rindex (__const char *__s, int __c) throw ();


extern int strcasecmp (__const char *__s1, __const char *__s2) throw ();


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n) throw ();


}
# 229 "../include/mico/os-net.h" 2

# 1 "/usr/include/errno.h" 1 3 4
# 29 "/usr/include/errno.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 30 "/usr/include/errno.h" 2 3 4


extern "C" {



# 1 "/usr/include/bits/errno.h" 1 3 4
# 25 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4



# 1 "/usr/include/asm/errno.h" 1 3 4
# 5 "/usr/include/linux/errno.h" 2 3 4
# 26 "/usr/include/bits/errno.h" 2 3 4
# 36 "/usr/include/bits/errno.h" 3 4
extern int errno;


extern int *__errno_location (void) throw () __attribute__ ((__const__));
# 37 "/usr/include/errno.h" 2 3 4
# 55 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;



}
# 69 "/usr/include/errno.h" 3 4
typedef int error_t;
# 231 "../include/mico/os-net.h" 2
# 1 "/usr/include/fcntl.h" 1 3 4
# 26 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/fcntl.h" 2 3 4


extern "C" {



# 1 "/usr/include/bits/fcntl.h" 1 3 4
# 25 "/usr/include/bits/fcntl.h" 3 4
# 1 "/usr/include/sys/types.h" 1 3 4
# 26 "/usr/include/bits/fcntl.h" 2 3 4
# 108 "/usr/include/bits/fcntl.h" 3 4
struct flock
  {
    short int l_type;
    short int l_whence;

    __off_t l_start;
    __off_t l_len;




    __pid_t l_pid;
  };


struct flock64
  {
    short int l_type;
    short int l_whence;
    __off64_t l_start;
    __off64_t l_len;
    __pid_t l_pid;
  };
# 34 "/usr/include/fcntl.h" 2 3 4



# 1 "/usr/include/sys/stat.h" 1 3 4
# 26 "/usr/include/sys/stat.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/sys/stat.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 29 "/usr/include/sys/stat.h" 2 3 4



# 1 "/usr/include/time.h" 1 3 4
# 33 "/usr/include/sys/stat.h" 2 3 4
# 87 "/usr/include/sys/stat.h" 3 4
extern "C" {

# 1 "/usr/include/bits/stat.h" 1 3 4
# 36 "/usr/include/bits/stat.h" 3 4
struct stat
  {
    __dev_t st_dev;
    unsigned short int __pad1;

    __ino_t st_ino;



    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned short int __pad2;

    __off_t st_size;



    unsigned long int st_blksize;


    __blkcnt_t st_blocks;



    __time_t st_atime;
    unsigned long int __unused1;
    __time_t st_mtime;
    unsigned long int __unused2;
    __time_t st_ctime;
    unsigned long int __unused3;
    unsigned long int __unused4;
    unsigned long int __unused5;
  };


struct stat64
  {
    __dev_t st_dev;
    unsigned short int __pad1;

    __ino64_t st_ino;
    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned short int __pad2;
    __off64_t st_size;
    unsigned long int st_blksize;

    __blkcnt64_t st_blocks;
    __time_t st_atime;
    unsigned long int __unused1;
    __time_t st_mtime;
    unsigned long int __unused2;
    __time_t st_ctime;
    unsigned long int __unused3;
    unsigned long int __unused4;
    unsigned long int __unused5;
  };
# 90 "/usr/include/sys/stat.h" 2 3 4
# 181 "/usr/include/sys/stat.h" 3 4
extern int stat (__const char *__file, struct stat *__buf) throw ();



extern int fstat (int __fd, struct stat *__buf) throw ();
# 197 "/usr/include/sys/stat.h" 3 4
extern int stat64 (__const char *__file, struct stat64 *__buf) throw ();
extern int fstat64 (int __fd, struct stat64 *__buf) throw ();






extern int lstat (__const char *__file, struct stat *__buf) throw ();
# 215 "/usr/include/sys/stat.h" 3 4
extern int lstat64 (__const char *__file, struct stat64 *__buf) throw ();






extern int chmod (__const char *__file, __mode_t __mode) throw ();



extern int fchmod (int __fd, __mode_t __mode) throw ();





extern __mode_t umask (__mode_t __mask) throw ();




extern __mode_t getumask (void) throw ();



extern int mkdir (__const char *__path, __mode_t __mode) throw ();





extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev) throw ();





extern int mkfifo (__const char *__path, __mode_t __mode) throw ();
# 279 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf) throw ();

extern int __xstat (int __ver, __const char *__filename, struct stat *__stat_buf) throw ();

extern int __lxstat (int __ver, __const char *__filename, struct stat *__stat_buf) throw ();
# 302 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf) throw ();

extern int __xstat64 (int __ver, __const char *__filename, struct stat64 *__stat_buf) throw ();

extern int __lxstat64 (int __ver, __const char *__filename, struct stat64 *__stat_buf) throw ();


extern int __xmknod (int __ver, __const char *__path, __mode_t __mode, __dev_t *__dev) throw ();





extern __inline__ int stat (__const char *__path,
                            struct stat *__statbuf) throw ()
{
  return __xstat (3, __path, __statbuf);
}


extern __inline__ int lstat (__const char *__path,
                             struct stat *__statbuf) throw ()
{
  return __lxstat (3, __path, __statbuf);
}


extern __inline__ int fstat (int __fd, struct stat *__statbuf) throw ()
{
  return __fxstat (3, __fd, __statbuf);
}


extern __inline__ int mknod (__const char *__path, __mode_t __mode,
                             __dev_t __dev) throw ()
{
  return __xmknod (1, __path, __mode, &__dev);
}



extern __inline__ int stat64 (__const char *__path,
                              struct stat64 *__statbuf) throw ()
{
  return __xstat64 (3, __path, __statbuf);
}


extern __inline__ int lstat64 (__const char *__path,
                               struct stat64 *__statbuf) throw ()
{
  return __lxstat64 (3, __path, __statbuf);
}


extern __inline__ int fstat64 (int __fd, struct stat64 *__statbuf) throw ()
{
  return __fxstat64 (3, __fd, __statbuf);
}




}
# 38 "/usr/include/fcntl.h" 2 3 4
# 60 "/usr/include/fcntl.h" 3 4
extern int __fcntl (int __fd, int __cmd, ...) throw ();
extern int fcntl (int __fd, int __cmd, ...) throw ();




extern int __open (__const char *__file, int __oflag, ...) throw ();

extern int open (__const char *__file, int __oflag, ...) throw ();
# 78 "/usr/include/fcntl.h" 3 4
extern int open64 (__const char *__file, int __oflag, ...) throw ();






extern int creat (__const char *__file, __mode_t __mode) throw ();
# 95 "/usr/include/fcntl.h" 3 4
extern int creat64 (__const char *__file, __mode_t __mode) throw ();
# 114 "/usr/include/fcntl.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) throw ();
# 124 "/usr/include/fcntl.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) throw ();



}
# 232 "../include/mico/os-net.h" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 26 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/unistd.h" 2 3 4

extern "C" {
# 175 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 176 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/environments.h" 2 3 4
# 180 "/usr/include/unistd.h" 2 3 4
# 190 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 191 "/usr/include/unistd.h" 2 3 4
# 199 "/usr/include/unistd.h" 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 200 "/usr/include/unistd.h" 2 3 4
# 235 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;
# 248 "/usr/include/unistd.h" 3 4
extern int access (__const char *__name, int __type) throw ();




extern int euidaccess (__const char *__name, int __type) throw ();
# 277 "/usr/include/unistd.h" 3 4
extern __off_t __lseek (int __fd, __off_t __offset, int __whence) throw ();

extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 291 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) throw ();



extern int __close (int __fd) throw ();
extern int close (int __fd) throw ();



extern ssize_t __read (int __fd, void * __buf, size_t __nbytes) throw ();
extern ssize_t read (int __fd, void * __buf, size_t __nbytes) throw ();


extern ssize_t __write (int __fd, __const void * __buf, size_t __n) throw ();
extern ssize_t write (int __fd, __const void * __buf, size_t __n) throw ();





extern ssize_t __pread64 (int __fd, void * __buf, size_t __nbytes, __off64_t __offset) throw ();



extern ssize_t __pwrite64 (int __fd, __const void * __buf, size_t __n, __off64_t __offset) throw ();



extern ssize_t pread (int __fd, void * __buf, size_t __nbytes, __off_t __offset) throw ();

extern ssize_t pwrite (int __fd, __const void * __buf, size_t __n, __off_t __offset) throw ();
# 338 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void * __buf, size_t __nbytes, __off64_t __offset) throw ();

extern ssize_t pwrite64 (int __fd, __const void * __buf, size_t __n, __off64_t __offset) throw ();
# 349 "/usr/include/unistd.h" 3 4
extern int pipe (int __pipedes[2]) throw ();
# 358 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 367 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds) throw ();






extern unsigned int ualarm (unsigned int __value, unsigned int __interval) throw ();




extern void usleep (unsigned int __useconds) throw ();





extern int pause (void) throw ();



extern int chown (__const char *__file, __uid_t __owner, __gid_t __group) throw ();




extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw ();




extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group) throw ();





extern int chdir (__const char *__path) throw ();



extern int fchdir (int __fd) throw ();
# 419 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw ();





extern char *get_current_dir_name (void) throw ();






extern char *getwd (char *__buf) throw ();




extern int dup (int __fd) throw ();


extern int dup2 (int __fd, int __fd2) throw ();


extern char **__environ;

extern char **environ;





extern int execve (__const char *__path, char *__const __argv[], char *__const __envp[]) throw ();





extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[]) throw ();






extern int execv (__const char *__path, char *__const __argv[]) throw ();



extern int execle (__const char *__path, __const char *__arg, ...) throw ();



extern int execl (__const char *__path, __const char *__arg, ...) throw ();



extern int execvp (__const char *__file, char *__const __argv[]) throw ();




extern int execlp (__const char *__file, __const char *__arg, ...) throw ();




extern int nice (int __inc) throw ();




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 25 "/usr/include/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS

  };


enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,




    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,



    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS

  };





enum
  {
    _CS_PATH




    ,
    _CS_LFS_CFLAGS = 1000,

    _CS_LFS_LDFLAGS,

    _CS_LFS_LIBS,

    _CS_LFS_LINTFLAGS,

    _CS_LFS64_CFLAGS,

    _CS_LFS64_LDFLAGS,

    _CS_LFS64_LIBS,

    _CS_LFS64_LINTFLAGS




    ,
    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,

    _CS_XBS5_ILP32_OFF32_LDFLAGS,

    _CS_XBS5_ILP32_OFF32_LIBS,

    _CS_XBS5_ILP32_OFF32_LINTFLAGS,

    _CS_XBS5_ILP32_OFFBIG_CFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LIBS,

    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,

    _CS_XBS5_LP64_OFF64_CFLAGS,

    _CS_XBS5_LP64_OFF64_LDFLAGS,

    _CS_XBS5_LP64_OFF64_LIBS,

    _CS_XBS5_LP64_OFF64_LINTFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LIBS,

    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS


  };
# 498 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (__const char *__path, int __name) throw ();


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw ();



extern size_t confstr (int __name, char *__buf, size_t __len) throw ();




extern __pid_t __getpid (void) throw ();
extern __pid_t getpid (void) throw ();


extern __pid_t getppid (void) throw ();




extern __pid_t getpgrp (void) throw ();
# 534 "/usr/include/unistd.h" 3 4
extern __pid_t __getpgid (__pid_t __pid) throw ();

extern __pid_t getpgid (__pid_t __pid) throw ();






extern int __setpgid (__pid_t __pid, __pid_t __pgid) throw ();
extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
# 561 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 579 "/usr/include/unistd.h" 3 4
extern __pid_t setsid (void) throw ();



extern __pid_t getsid (__pid_t __pid) throw ();



extern __uid_t getuid (void) throw ();


extern __uid_t geteuid (void) throw ();


extern __gid_t getgid (void) throw ();


extern __gid_t getegid (void) throw ();




extern int getgroups (int __size, __gid_t __list[]) throw ();



extern int group_member (__gid_t __gid) throw ();






extern int setuid (__uid_t __uid) throw ();




extern int setreuid (__uid_t __ruid, __uid_t __euid) throw ();




extern int seteuid (__uid_t __uid) throw ();






extern int setgid (__gid_t __gid) throw ();




extern int setregid (__gid_t __rgid, __gid_t __egid) throw ();




extern int setegid (__gid_t __gid) throw ();






extern __pid_t __fork (void) throw ();
extern __pid_t fork (void) throw ();






extern __pid_t vfork (void) throw ();





extern char *ttyname (int __fd) throw ();



extern int ttyname_r (int __fd, char *__buf, size_t __buflen) throw ();



extern int isatty (int __fd) throw ();




extern int ttyslot (void) throw ();




extern int link (__const char *__from, __const char *__to) throw ();



extern int symlink (__const char *__from, __const char *__to) throw ();




extern int readlink (__const char *__path, char *__buf, size_t __len) throw ();



extern int unlink (__const char *__name) throw ();


extern int rmdir (__const char *__path) throw ();



extern __pid_t tcgetpgrp (int __fd) throw ();


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();



extern char *getlogin (void) throw ();
# 715 "/usr/include/unistd.h" 3 4
extern int setlogin (__const char *__name) throw ();
# 724 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 27 "/usr/include/getopt.h" 3 4
extern "C" {
# 36 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 50 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 134 "/usr/include/getopt.h" 3 4
extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
# 163 "/usr/include/getopt.h" 3 4
}
# 725 "/usr/include/unistd.h" 2 3 4
# 733 "/usr/include/unistd.h" 3 4
extern int gethostname (char *__name, size_t __len) throw ();



extern int sethostname (__const char *__name, size_t __len) throw ();



extern int sethostid (long int __id) throw ();





extern int getdomainname (char *__name, size_t __len) throw ();
extern int setdomainname (__const char *__name, size_t __len) throw ();



extern int fsync (int __fd) throw ();





extern int vhangup (void) throw ();


extern int revoke (__const char *__file) throw ();







extern int profil (unsigned short int *__sample_buffer, size_t __size, size_t __offset, unsigned int __scale) throw ();






extern int acct (__const char *__name) throw ();



extern int chroot (__const char *__path) throw ();



extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();




extern char *getpass (__const char *__prompt) throw ();




extern int daemon (int __nochdir, int __noclose) throw ();







extern long int gethostid (void) throw ();


extern int sync (void) throw ();




extern int __getpagesize (void) throw () __attribute__ ((__const__));
extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int truncate (__const char *__file, __off_t __length) throw ();
# 829 "/usr/include/unistd.h" 3 4
extern int truncate64 (__const char *__file, __off64_t __length) throw ();



extern int __ftruncate (int __fd, __off_t __length) throw ();

extern int ftruncate (int __fd, __off_t __length) throw ();
# 845 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw ();





extern int getdtablesize (void) throw ();
# 860 "/usr/include/unistd.h" 3 4
extern int brk (void * __addr) throw ();


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 864 "/usr/include/unistd.h" 2 3 4





extern void * __sbrk (ptrdiff_t __delta) throw ();
extern void * sbrk (ptrdiff_t __delta) throw ();
# 885 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 938 "/usr/include/unistd.h" 3 4
extern int __libc_enable_secure;






extern int fdatasync (int __fildes) throw ();







extern char *crypt (__const char *__key, __const char *__salt) throw ();


extern void setkey (__const char *__key) throw ();



extern void encrypt (char *__block, int __edflag) throw ();






extern void swab (__const void * __from, void * __to, ssize_t __n) throw ();







extern char *ctermid (char *__s) throw ();



extern char *cuserid (char *__s) throw ();


extern int rename (__const char *__old, __const char *__new) throw ();
# 999 "/usr/include/unistd.h" 3 4
extern int pthread_atfork (void (*__prepare) (void), void (*__parent) (void), void (*__child) (void)) throw ();




}
# 233 "../include/mico/os-net.h" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 234 "../include/mico/os-net.h" 2
# 1 "/usr/include/sys/time.h" 1 3 4
# 22 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/sys/time.h" 2 3 4

# 1 "/usr/include/time.h" 1 3 4
# 25 "/usr/include/sys/time.h" 2 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 26 "/usr/include/sys/time.h" 2 3 4


# 1 "/usr/include/bits/time.h" 1 3 4
# 49 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 50 "/usr/include/bits/time.h" 2 3 4



struct timeval
  {
    __time_t tv_sec;
    __time_t tv_usec;
  };
# 29 "/usr/include/sys/time.h" 2 3 4


extern "C" {
# 46 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };






extern int gettimeofday (struct timeval *__tv, struct timezone *__tz) throw ();




extern int settimeofday (__const struct timeval *__tv, __const struct timezone *__tz) throw ();






extern int adjtime (__const struct timeval *__delta, struct timeval *__olddelta) throw ();




enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };



extern int getitimer (enum __itimer_which __which, struct itimerval *__value) throw ();





extern int setitimer (enum __itimer_which __which, __const struct itimerval *__new, struct itimerval *__old) throw ();





extern int utimes (__const char *__file, struct timeval __tvp[2]) throw ();
# 143 "/usr/include/sys/time.h" 3 4
}
# 235 "../include/mico/os-net.h" 2

# 1 "/usr/include/sys/socket.h" 1 3 4
# 23 "/usr/include/sys/socket.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 24 "/usr/include/sys/socket.h" 2 3 4

extern "C" {


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 29 "/usr/include/sys/socket.h" 2 3 4





# 1 "/usr/include/bits/socket.h" 1 3 4
# 29 "/usr/include/bits/socket.h" 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 30 "/usr/include/bits/socket.h" 2 3 4

# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 1 3 4
# 32 "/usr/include/bits/socket.h" 2 3 4
# 1 "/usr/include/sys/types.h" 1 3 4
# 33 "/usr/include/bits/socket.h" 2 3 4


typedef unsigned int socklen_t;


enum __socket_type
{
  SOCK_STREAM = 1,


  SOCK_DGRAM = 2,


  SOCK_RAW = 3,

  SOCK_RDM = 4,

  SOCK_SEQPACKET = 5,


  SOCK_PACKET = 10



};
# 133 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/include/bits/sockaddr.h" 1 3 4
# 29 "/usr/include/bits/sockaddr.h" 3 4
typedef unsigned short int sa_family_t;
# 42 "/usr/include/bits/sockaddr.h" 3 4
extern int __libc_sa_len (sa_family_t __af) throw ();
# 134 "/usr/include/bits/socket.h" 2 3 4


struct sockaddr
  {
    sa_family_t sa_family;
    char sa_data[14];
  };
# 153 "/usr/include/bits/socket.h" 3 4
struct sockaddr_storage
  {
    sa_family_t __ss_family;
    __uint32_t __ss_align;
    char __ss_padding[(128 - (2 * sizeof (__uint32_t)))];
  };



enum
  {
    MSG_OOB = 0x01,

    MSG_PEEK = 0x02,

    MSG_DONTROUTE = 0x04,



    MSG_TRYHARD = MSG_DONTROUTE,


    MSG_CTRUNC = 0x08,

    MSG_PROXY = 0x10,

    MSG_TRUNC = 0x20,

    MSG_DONTWAIT = 0x40,

    MSG_EOR = 0x80,

    MSG_WAITALL = 0x100,

    MSG_FIN = 0x200,

    MSG_SYN = 0x400,

    MSG_URG = 0x800,

    MSG_RST = 0x1000,

    MSG_ERRQUEUE = 0x2000,

    MSG_NOSIGNAL = 0x4000

  };




struct msghdr
  {
    void * msg_name;
    socklen_t msg_namelen;

    struct iovec *msg_iov;
    size_t msg_iovlen;

    void * msg_control;
    size_t msg_controllen;

    int msg_flags;
  };


struct cmsghdr
  {
    size_t cmsg_len;

    int cmsg_level;
    int cmsg_type;

    unsigned char __cmsg_data[0];


  };
# 247 "/usr/include/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ();





extern __inline struct cmsghdr *
__cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))

    return 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
                               + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & ~(sizeof (size_t) - 1)));
  if ((unsigned char *) (__cmsg + 1) >= ((unsigned char *) __mhdr->msg_control
                                         + __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & ~(sizeof (size_t) - 1))
          >= ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))

    return 0;
  return __cmsg;
}




enum
  {
    SCM_RIGHTS = 0x01,


    SCM_CREDENTIALS = 0x02,


    __SCM_CONNECT = 0x03
  };



struct ucred
{
  pid_t pid;
  uid_t uid;
  gid_t gid;
};


# 1 "/usr/include/asm/socket.h" 1 3 4



# 1 "/usr/include/asm/sockios.h" 1 3 4
# 5 "/usr/include/asm/socket.h" 2 3 4
# 296 "/usr/include/bits/socket.h" 2 3 4



struct linger
  {
    int l_onoff;
    int l_linger;
  };
# 35 "/usr/include/sys/socket.h" 2 3 4




struct osockaddr
  {
    unsigned short int sa_family;
    unsigned char sa_data[14];
  };




enum
{
  SHUT_RD = 0,

  SHUT_WR,

  SHUT_RDWR

};
# 100 "/usr/include/sys/socket.h" 3 4
extern int socket (int __domain, int __type, int __protocol) throw ();





extern int socketpair (int __domain, int __type, int __protocol, int __fds[2]) throw ();



extern int bind (int __fd, __const struct sockaddr * __addr, socklen_t __len) throw ();


extern int getsockname (int __fd, struct sockaddr * __addr, socklen_t *__len) throw ();






extern int __connect (int __fd, __const struct sockaddr * __addr, socklen_t __len) throw ();

extern int connect (int __fd, __const struct sockaddr * __addr, socklen_t __len) throw ();




extern int getpeername (int __fd, struct sockaddr * __addr, socklen_t *__len) throw ();




extern int __send (int __fd, __const void * __buf, size_t __n, int __flags) throw ();

extern int send (int __fd, __const void * __buf, size_t __n, int __flags) throw ();




extern int recv (int __fd, void * __buf, size_t __n, int __flags) throw ();



extern int sendto (int __fd, __const void * __buf, size_t __n, int __flags, __const struct sockaddr * __addr, socklen_t __addr_len) throw ();







extern int recvfrom (int __fd, void * __buf, size_t __n, int __flags, struct sockaddr * __addr, socklen_t *__addr_len) throw ();





extern int sendmsg (int __fd, __const struct msghdr *__message, int __flags) throw ();




extern int recvmsg (int __fd, struct msghdr *__message, int __flags) throw ();





extern int getsockopt (int __fd, int __level, int __optname, void * __optval, socklen_t *__optlen) throw ();





extern int setsockopt (int __fd, int __level, int __optname, __const void * __optval, socklen_t __optlen) throw ();






extern int listen (int __fd, unsigned int __n) throw ();






extern int accept (int __fd, struct sockaddr * __addr, socklen_t *__addr_len) throw ();
# 197 "/usr/include/sys/socket.h" 3 4
extern int shutdown (int __fd, int __how) throw ();





extern int isfdtype (int __fd, int __fdtype) throw ();

}
# 237 "../include/mico/os-net.h" 2

# 1 "/usr/include/sys/un.h" 1 3 4
# 22 "/usr/include/sys/un.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 23 "/usr/include/sys/un.h" 2 3 4

# 1 "/usr/include/string.h" 1 3 4
# 25 "/usr/include/sys/un.h" 2 3 4


# 1 "/usr/include/bits/sockaddr.h" 1 3 4
# 28 "/usr/include/sys/un.h" 2 3 4

extern "C" {


struct sockaddr_un
  {
    sa_family_t sun_family;
    char sun_path[108];
  };






}
# 239 "../include/mico/os-net.h" 2

# 1 "/usr/include/netinet/in.h" 1 3 4
# 22 "/usr/include/netinet/in.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/netinet/in.h" 2 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 1 3 4
# 24 "/usr/include/netinet/in.h" 2 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4

# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4
# 50 "/usr/include/stdint.h" 3 4
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;



__extension__
typedef unsigned long long int uint64_t;






typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;



__extension__
typedef long long int int_least64_t;



typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;



__extension__
typedef unsigned long long int uint_least64_t;






typedef signed char int_fast8_t;





typedef int int_fast16_t;
typedef int int_fast32_t;
__extension__
typedef long long int int_fast64_t;



typedef unsigned char uint_fast8_t;





typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
__extension__
typedef unsigned long long int uint_fast64_t;
# 127 "/usr/include/stdint.h" 3 4
typedef unsigned int uintptr_t;
# 136 "/usr/include/stdint.h" 3 4
__extension__
typedef long long int intmax_t;
__extension__
typedef unsigned long long int uintmax_t;
# 25 "/usr/include/netinet/in.h" 2 3 4

# 1 "/usr/include/sys/types.h" 1 3 4
# 27 "/usr/include/netinet/in.h" 2 3 4
# 1 "/usr/include/bits/socket.h" 1 3 4
# 28 "/usr/include/netinet/in.h" 2 3 4


extern "C" {


enum
  {
    IPPROTO_IP = 0,
    IPPROTO_HOPOPTS = 0,
    IPPROTO_ICMP = 1,
    IPPROTO_IGMP = 2,
    IPPROTO_IPIP = 4,
    IPPROTO_TCP = 6,
    IPPROTO_EGP = 8,
    IPPROTO_PUP = 12,
    IPPROTO_UDP = 17,
    IPPROTO_IDP = 22,
    IPPROTO_TP = 29,
    IPPROTO_IPV6 = 41,
    IPPROTO_ROUTING = 43,
    IPPROTO_FRAGMENT = 44,
    IPPROTO_RSVP = 46,
    IPPROTO_GRE = 47,
    IPPROTO_ESP = 50,
    IPPROTO_AH = 51,
    IPPROTO_ICMPV6 = 58,
    IPPROTO_NONE = 59,
    IPPROTO_DSTOPTS = 60,
    IPPROTO_MTP = 92,
    IPPROTO_ENCAP = 98,
    IPPROTO_PIM = 103,
    IPPROTO_COMP = 108,
    IPPROTO_RAW = 255,
    IPPROTO_MAX
  };


enum
  {
    IPPORT_ECHO = 7,
    IPPORT_DISCARD = 9,
    IPPORT_SYSTAT = 11,
    IPPORT_DAYTIME = 13,
    IPPORT_NETSTAT = 15,
    IPPORT_FTP = 21,
    IPPORT_TELNET = 23,
    IPPORT_SMTP = 25,
    IPPORT_TIMESERVER = 37,
    IPPORT_NAMESERVER = 42,
    IPPORT_WHOIS = 43,
    IPPORT_MTP = 57,

    IPPORT_TFTP = 69,
    IPPORT_RJE = 77,
    IPPORT_FINGER = 79,
    IPPORT_TTYLINK = 87,
    IPPORT_SUPDUP = 95,


    IPPORT_EXECSERVER = 512,
    IPPORT_LOGINSERVER = 513,
    IPPORT_CMDSERVER = 514,
    IPPORT_EFSSERVER = 520,


    IPPORT_BIFFUDP = 512,
    IPPORT_WHOSERVER = 513,
    IPPORT_ROUTESERVER = 520,


    IPPORT_RESERVED = 1024,


    IPPORT_USERRESERVED = 5000
  };



struct in_addr
  {
    uint32_t s_addr;
  };
# 162 "/usr/include/netinet/in.h" 3 4
struct in6_addr
  {
    union
      {
        uint8_t u6_addr8[16];
        uint16_t u6_addr16[8];
        uint32_t u6_addr32[4];



      } in6_u;




  };

extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;







# 1 "/usr/include/bits/sockaddr.h" 1 3 4
# 189 "/usr/include/netinet/in.h" 2 3 4



struct sockaddr_in
  {
    sa_family_t sin_family;
    uint16_t sin_port;
    struct in_addr sin_addr;


    unsigned char sin_zero[sizeof (struct sockaddr) -
                           (sizeof (unsigned short int)) -
                           sizeof (uint16_t) -
                           sizeof (struct in_addr)];
  };


struct sockaddr_in6
  {
    sa_family_t sin6_family;
    uint16_t sin6_port;
    uint32_t sin6_flowinfo;
    struct in6_addr sin6_addr;
  };


struct ipv6_mreq
  {

    struct in6_addr ipv6mr_multiaddr;


    unsigned int ipv6mr_interface;
  };


# 1 "/usr/include/bits/in.h" 1 3 4
# 66 "/usr/include/bits/in.h" 3 4
struct ip_opts
  {
    struct in_addr ip_dst;
    char ip_opts[40];
  };


struct ip_mreq
  {
    struct in_addr imr_multiaddr;
    struct in_addr imr_interface;
  };


struct ip_mreqn
  {
    struct in_addr imr_multiaddr;
    struct in_addr imr_address;
    int imr_ifindex;
  };


struct in_pktinfo
  {
    int ipi_ifindex;
    struct in_addr ipi_spec_dst;
    struct in_addr ipi_addr;
  };
# 226 "/usr/include/netinet/in.h" 2 3 4
# 234 "/usr/include/netinet/in.h" 3 4
extern uint32_t ntohl (uint32_t __netlong) throw ();
extern uint16_t ntohs (uint16_t __netshort) throw ();
extern uint32_t htonl (uint32_t __hostlong) throw ();
extern uint16_t htons (uint16_t __hostshort) throw ();

# 1 "/usr/include/endian.h" 1 3 4
# 240 "/usr/include/netinet/in.h" 2 3 4


# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 243 "/usr/include/netinet/in.h" 2 3 4
# 291 "/usr/include/netinet/in.h" 3 4
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();
# 311 "/usr/include/netinet/in.h" 3 4
struct in6_pktinfo
  {
    struct in6_addr ipi6_addr;
    unsigned int ipi6_ifindex;
  };

}
# 241 "../include/mico/os-net.h" 2
# 1 "/usr/include/arpa/inet.h" 1 3 4
# 22 "/usr/include/arpa/inet.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/arpa/inet.h" 2 3 4

# 1 "/usr/include/sys/types.h" 1 3 4
# 25 "/usr/include/arpa/inet.h" 2 3 4
# 1 "/usr/include/netinet/in.h" 1 3 4
# 26 "/usr/include/arpa/inet.h" 2 3 4

extern "C" {



extern u_int32_t inet_addr (__const char *__cp) throw ();



extern int inet_aton (__const char *__cp, struct in_addr *__inp) throw ();


extern u_int32_t inet_lnaof (struct in_addr __in) throw ();



extern struct in_addr inet_makeaddr (u_int32_t __net, u_int32_t __host) throw ();



extern char *inet_neta (u_int32_t __net, char *__buf, size_t __len) throw ();


extern u_int32_t inet_netof (struct in_addr __in) throw ();



extern u_int32_t inet_network (__const char *__cp) throw ();




extern char *inet_net_ntop (int __af, __const void *__cp, int __bits, char *__buf, size_t __len) throw ();





extern int inet_net_pton (int __af, __const char *__cp, void *__buf, size_t __len) throw ();




extern char *inet_ntoa (struct in_addr __in) throw ();




extern int inet_pton (int __af, __const char *__cp, void *__buf) throw ();




extern __const char *inet_ntop (int __af, __const void *__cp, char *__buf, size_t __len) throw ();





extern unsigned int inet_nsap_addr (__const char *__cp, unsigned char *__buf, int __len) throw ();




extern char *inet_nsap_ntoa (int __len, __const unsigned char *__cp, char *__buf) throw ();


}
# 242 "../include/mico/os-net.h" 2

# 1 "/usr/include/netinet/tcp.h" 1 3 4
# 39 "/usr/include/netinet/tcp.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 40 "/usr/include/netinet/tcp.h" 2 3 4
# 1 "/usr/include/sys/types.h" 1 3 4
# 41 "/usr/include/netinet/tcp.h" 2 3 4

extern "C" {
# 77 "/usr/include/netinet/tcp.h" 3 4
struct tcphdr
  {
    u_int16_t source;
    u_int16_t dest;
    u_int32_t seq;
    u_int32_t ack_seq;

    u_int16_t res1:4;
    u_int16_t doff:4;
    u_int16_t fin:1;
    u_int16_t syn:1;
    u_int16_t rst:1;
    u_int16_t psh:1;
    u_int16_t ack:1;
    u_int16_t urg:1;
    u_int16_t res2:2;
# 106 "/usr/include/netinet/tcp.h" 3 4
    u_int16_t window;
    u_int16_t check;
    u_int16_t urg_ptr;
};


enum
{
  TCP_ESTABLISHED = 1,
  TCP_SYN_SENT,
  TCP_SYN_RECV,
  TCP_FIN_WAIT1,
  TCP_FIN_WAIT2,
  TCP_TIME_WAIT,
  TCP_CLOSE,
  TCP_CLOSE_WAIT,
  TCP_LAST_ACK,
  TCP_LISTEN,
  TCP_CLOSING
};
# 164 "/usr/include/netinet/tcp.h" 3 4
}
# 244 "../include/mico/os-net.h" 2

# 1 "/usr/include/netdb.h" 1 3 4
# 26 "/usr/include/netdb.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/netdb.h" 2 3 4



# 1 "/usr/include/rpc/netdb.h" 1 3 4
# 39 "/usr/include/rpc/netdb.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 40 "/usr/include/rpc/netdb.h" 2 3 4


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 43 "/usr/include/rpc/netdb.h" 2 3 4

extern "C" {

struct rpcent
{
  char *r_name;
  char **r_aliases;
  int r_number;
};

extern void setrpcent (int _stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (__const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();


extern int getrpcbyname_r (__const char *__name, struct rpcent *__result_buf, char *__buffer, size_t __buflen, struct rpcent **__result) throw ();



extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf, char *__buffer, size_t __buflen, struct rpcent **__result) throw ();



extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer, size_t __buflen, struct rpcent **__result) throw ();



}
# 31 "/usr/include/netdb.h" 2 3 4
# 1 "/usr/include/sys/socket.h" 1 3 4
# 32 "/usr/include/netdb.h" 2 3 4

# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 34 "/usr/include/netdb.h" 2 3 4
# 44 "/usr/include/netdb.h" 3 4
extern "C" {


extern int h_errno;


extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
# 85 "/usr/include/netdb.h" 3 4
extern void herror (__const char *__str) throw ();


extern __const char *hstrerror (int __err_num) throw ();




struct hostent
{
  char *h_name;
  char **h_aliases;
  int h_addrtype;
  int h_length;
  char **h_addr_list;

};



extern void sethostent (int __stay_open) throw ();


extern void endhostent (void) throw ();



extern struct hostent *gethostent (void) throw ();



extern struct hostent *gethostbyaddr (__const char *__addr, size_t __len, int __type) throw ();



extern struct hostent *gethostbyname (__const char *__name) throw ();




extern struct hostent *gethostbyname2 (__const char *__name, int __af) throw ();







extern int gethostent_r (struct hostent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct hostent **__restrict __result, int *__restrict __h_errnop) throw ();




extern int gethostbyaddr_r (__const char *__restrict __addr, size_t __len, int __type, struct hostent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct hostent **__restrict __result, int *__restrict __h_errnop) throw ();






extern int gethostbyname_r (__const char *__restrict __name, struct hostent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct hostent **__restrict __result, int *__restrict __h_errnop) throw ();





extern int gethostbyname2_r (__const char *__restrict __name, int __af, struct hostent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct hostent **__restrict __result, int *__restrict __h_errnop) throw ();
# 169 "/usr/include/netdb.h" 3 4
struct netent
{
  char *n_name;
  char **n_aliases;
  int n_addrtype;
  unsigned long int n_net;
};



extern void setnetent (int __stay_open) throw ();


extern void endnetent (void) throw ();



extern struct netent *getnetent (void) throw ();



extern struct netent *getnetbyaddr (unsigned long int __net, int __type) throw ();



extern struct netent *getnetbyname (__const char *__name) throw ();







extern int getnetent_r (struct netent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct netent **__restrict __result, int *__restrict __h_errnop) throw ();




extern int getnetbyaddr_r (unsigned long int __net, int __type, struct netent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct netent **__restrict __result, int *__restrict __h_errnop) throw ();





extern int getnetbyname_r (__const char *__restrict __name, struct netent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct netent **__restrict __result, int *__restrict __h_errnop) throw ();
# 222 "/usr/include/netdb.h" 3 4
struct servent
{
  char *s_name;
  char **s_aliases;
  int s_port;
  char *s_proto;
};



extern void setservent (int __stay_open) throw ();


extern void endservent (void) throw ();



extern struct servent *getservent (void) throw ();



extern struct servent *getservbyname (__const char *__name, __const char *__proto) throw ();




extern struct servent *getservbyport (int __port, __const char *__proto) throw ();





extern int getservent_r (struct servent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct servent **__restrict __result) throw ();



extern int getservbyname_r (__const char *__restrict __name, __const char *__restrict __proto, struct servent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct servent **__restrict __result) throw ();





extern int getservbyport_r (int __port, __const char *__restrict __proto, struct servent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct servent **__restrict __result) throw ();







struct protoent
{
  char *p_name;
  char **p_aliases;
  int p_proto;
};



extern void setprotoent (int __stay_open) throw ();


extern void endprotoent (void) throw ();



extern struct protoent *getprotoent (void) throw ();


extern struct protoent *getprotobyname (__const char *__name) throw ();


extern struct protoent *getprotobynumber (int __proto) throw ();





extern int getprotoent_r (struct protoent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct protoent **__restrict __result) throw ();



extern int getprotobyname_r (__const char *__restrict __name, struct protoent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct protoent **__restrict __result) throw ();




extern int getprotobynumber_r (int __proto, struct protoent *__restrict __result_buf, char *__restrict __buf, size_t __buflen, struct protoent **__restrict __result) throw ();







extern int setnetgrent (__const char *__netgroup) throw ();


extern void endnetgrent (void) throw ();



extern int getnetgrent (char **__restrict __hostp, char **__restrict __userp, char **__restrict __domainp) throw ();




extern int innetgr (__const char *__netgroup, __const char *__host, __const char *__user, __const char *domain) throw ();




extern int getnetgrent_r (char **__restrict __hostp, char **__restrict __userp, char **__restrict __domainp, char *__restrict __buffer, size_t __buflen) throw ();
# 348 "/usr/include/netdb.h" 3 4
extern int rcmd (char **__restrict __ahost, unsigned short int __rport, __const char *__restrict __locuser, __const char *__restrict __remuser, __const char *__restrict __cmd, int *__restrict __fd2p) throw ();
# 358 "/usr/include/netdb.h" 3 4
extern int rexec (char **__restrict __ahost, int __rport, __const char *__restrict __name, __const char *__restrict __pass, __const char *__restrict __cmd, int *__restrict __fd2p) throw ();
# 367 "/usr/include/netdb.h" 3 4
extern int ruserok (__const char *__rhost, int __suser, __const char *__remuser, __const char *__locuser) throw ();





extern int rresvport (int *__alport) throw ();






struct addrinfo
{
  int ai_flags;
  int ai_family;
  int ai_socktype;
  int ai_protocol;
  int ai_addrlen;
  struct sockaddr *ai_addr;
  char *ai_canonname;
  struct addrinfo *ai_next;
};
# 421 "/usr/include/netdb.h" 3 4
extern int getaddrinfo (__const char *__restrict __name, __const char *__restrict __service, __const struct addrinfo *__restrict __req, struct addrinfo **__restrict __pai) throw ();





extern void freeaddrinfo (struct addrinfo *__ai) throw ();


extern char *gai_strerror (int __ecode) throw ();


extern int getnameinfo (__const struct sockaddr *__restrict __sa, socklen_t __salen, char *__restrict __host, size_t __hostlen, char *__restrict __serv, size_t __servlen, int __flags) throw ();







}
# 246 "../include/mico/os-net.h" 2
# 1 "/usr/include/signal.h" 1 3 4
# 29 "/usr/include/signal.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 30 "/usr/include/signal.h" 2 3 4

extern "C" {

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 103 "/usr/include/bits/sigset.h" 3 4
extern int __sigismember (__const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
# 117 "/usr/include/bits/sigset.h" 3 4
extern __inline int __sigismember (__const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
extern __inline int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
extern __inline int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
# 34 "/usr/include/signal.h" 2 3 4







typedef __sig_atomic_t sig_atomic_t;
# 55 "/usr/include/signal.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 56 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/bits/signum.h" 1 3 4
# 57 "/usr/include/signal.h" 2 3 4
# 71 "/usr/include/signal.h" 3 4
typedef void (*__sighandler_t) (int);




extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler) throw ();


extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler) throw ();






extern __sighandler_t signal (int __sig, __sighandler_t __handler) throw ();
# 101 "/usr/include/signal.h" 3 4
extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler) throw ();






extern int kill (__pid_t __pid, int __sig) throw ();






extern int killpg (__pid_t __pgrp, int __sig) throw ();



extern int raise (int __sig) throw ();



extern __sighandler_t ssignal (int __sig, __sighandler_t __handler) throw ();
extern int gsignal (int __sig) throw ();




extern void psignal (int __sig, __const char *__s) throw ();
# 138 "/usr/include/signal.h" 3 4
extern int __sigpause (int __sig_or_mask, int __is_sig) throw ();




extern int sigpause (int __mask) throw ();
# 163 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw ();


extern int sigsetmask (int __mask) throw ();


extern int siggetmask (void) throw ();
# 178 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;







# 1 "/usr/include/time.h" 1 3 4
# 192 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/bits/siginfo.h" 1 3 4
# 29 "/usr/include/bits/siginfo.h" 3 4
typedef union sigval
  {
    int sival_int;
    void *sival_ptr;
  } sigval_t;




typedef struct siginfo
  {
    int si_signo;
    int si_errno;

    int si_code;

    union
      {
        int _pad[((128 / sizeof (int)) - 3)];


        struct
          {
            __pid_t si_pid;
            __uid_t si_uid;
          } _kill;


        struct
          {
            unsigned int _timer1;
            unsigned int _timer2;
          } _timer;


        struct
          {
            __pid_t si_pid;
            __uid_t si_uid;
            sigval_t si_sigval;
          } _rt;


        struct
          {
            __pid_t si_pid;
            __uid_t si_uid;
            int si_status;
            __clock_t si_utime;
            __clock_t si_stime;
          } _sigchld;


        struct
          {
            void *si_addr;
          } _sigfault;


        struct
          {
            int si_band;
            int si_fd;
          } _sigpoll;
      } _sifields;
  } siginfo_t;
# 113 "/usr/include/bits/siginfo.h" 3 4
enum
{
  SI_SIGIO = -5,

  SI_ASYNCIO,

  SI_MESGQ,

  SI_TIMER,

  SI_QUEUE,

  SI_USER

};



enum
{
  ILL_ILLOPC = 1,

  ILL_ILLOPN,

  ILL_ILLADR,

  ILL_ILLTRP,

  ILL_PRVOPC,

  ILL_PRVREG,

  ILL_COPROC,

  ILL_BADSTK

};


enum
{
  FPE_INTDIV = 1,

  FPE_INTOVF,

  FPE_FLTDIV,

  FPE_FLTOVF,

  FPE_FLTUND,

  FPE_FLTRES,

  FPE_FLTINV,

  FPE_FLTSUB

};


enum
{
  SEGV_MAPERR = 1,

  SEGV_ACCERR

};


enum
{
  BUS_ADRALN = 1,

  BUS_ADRERR,

  BUS_OBJERR

};


enum
{
  TRAP_BRKPT = 1,

  TRAP_TRACE

};


enum
{
  CLD_EXITED = 1,

  CLD_KILLED,

  CLD_DUMPED,

  CLD_TRAPPED,

  CLD_STOPPED,

  CLD_CONTINUED

};


enum
{
  POLL_IN = 1,

  POLL_OUT,

  POLL_MSG,

  POLL_ERR,

  POLL_PRI,

  POLL_HUP

};
# 246 "/usr/include/bits/siginfo.h" 3 4
typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
        int _pad[((64 / sizeof (int)) - 3)];

        struct
          {
            void (*_function) (sigval_t);
            void *_attribute;
          } _sigev_thread;
      } _sigev_un;
  } sigevent_t;






enum
{
  SIGEV_SIGNAL = 0,

  SIGEV_NONE,

  SIGEV_THREAD

};
# 195 "/usr/include/signal.h" 2 3 4



extern int sigemptyset (sigset_t *__set) throw ();


extern int sigfillset (sigset_t *__set) throw ();


extern int sigaddset (sigset_t *__set, int __signo) throw ();


extern int sigdelset (sigset_t *__set, int __signo) throw ();


extern int sigismember (__const sigset_t *__set, int __signo) throw ();



extern int sigisemptyset (__const sigset_t *__set) throw ();


extern int sigandset (sigset_t *__set, __const sigset_t *__left, __const sigset_t *__right) throw ();



extern int sigorset (sigset_t *__set, __const sigset_t *__left, __const sigset_t *__right) throw ();





# 1 "/usr/include/bits/sigaction.h" 1 3 4
# 25 "/usr/include/bits/sigaction.h" 3 4
struct sigaction
  {


    union
      {

        __sighandler_t sa_handler;

        void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;







    __sigset_t sa_mask;


    int sa_flags;


    void (*sa_restorer) (void);
  };
# 228 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, __const sigset_t *__set, sigset_t *__oset) throw ();




extern int sigsuspend (__const sigset_t *__set) throw ();


extern int __sigaction (int __sig, __const struct sigaction *__act, struct sigaction *__oact) throw ();

extern int sigaction (int __sig, __const struct sigaction *__act, struct sigaction *__oact) throw ();



extern int sigpending (sigset_t *__set) throw ();



extern int sigwait (__const sigset_t *__set, int *__sig) throw ();



extern int sigwaitinfo (__const sigset_t *__set, siginfo_t *__info) throw ();



extern int sigtimedwait (__const sigset_t *__set, siginfo_t *__info, __const struct timespec *__timeout) throw ();




extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val) throw ();
# 271 "/usr/include/signal.h" 3 4
extern __const char *__const _sys_siglist[64];
extern __const char *__const sys_siglist[64];


struct sigvec
  {
    __sighandler_t sv_handler;
    int sv_mask;

    int sv_flags;

  };
# 295 "/usr/include/signal.h" 3 4
extern int sigvec (int __sig, __const struct sigvec *__vec, struct sigvec *__ovec) throw ();




# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 28 "/usr/include/bits/sigcontext.h" 3 4
# 1 "/usr/include/asm/sigcontext.h" 1 3 4
# 12 "/usr/include/asm/sigcontext.h" 3 4
struct _fpreg {
        unsigned short significand[4];
        unsigned short exponent;
};

struct _fpstate {
        unsigned long cw,
                        sw,
                        tag,
                        ipoff,
                        cssel,
                        dataoff,
                        datasel;
        struct _fpreg _st[8];
        unsigned long status;
};

struct sigcontext {
        unsigned short gs, __gsh;
        unsigned short fs, __fsh;
        unsigned short es, __esh;
        unsigned short ds, __dsh;
        unsigned long edi;
        unsigned long esi;
        unsigned long ebp;
        unsigned long esp;
        unsigned long ebx;
        unsigned long edx;
        unsigned long ecx;
        unsigned long eax;
        unsigned long trapno;
        unsigned long err;
        unsigned long eip;
        unsigned short cs, __csh;
        unsigned long eflags;
        unsigned long esp_at_signal;
        unsigned short ss, __ssh;
        struct _fpstate * fpstate;
        unsigned long oldmask;
        unsigned long cr2;
};
# 29 "/usr/include/bits/sigcontext.h" 2 3 4
# 301 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) throw ();
# 313 "/usr/include/signal.h" 3 4
extern int siginterrupt (int __sig, int __interrupt) throw ();

# 1 "/usr/include/bits/sigstack.h" 1 3 4
# 26 "/usr/include/bits/sigstack.h" 3 4
struct sigstack
  {
    void * ss_sp;
    int ss_onstack;
  };



enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};
# 50 "/usr/include/bits/sigstack.h" 3 4
typedef struct sigaltstack
  {
    void * ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 316 "/usr/include/signal.h" 2 3 4

# 1 "/usr/include/ucontext.h" 1 3 4
# 24 "/usr/include/ucontext.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 25 "/usr/include/ucontext.h" 2 3 4


# 1 "/usr/include/sys/ucontext.h" 1 3 4
# 22 "/usr/include/sys/ucontext.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 23 "/usr/include/sys/ucontext.h" 2 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 24 "/usr/include/sys/ucontext.h" 2 3 4



# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 28 "/usr/include/sys/ucontext.h" 2 3 4



# 1 "/usr/include/sys/user.h" 1 3 4
# 26 "/usr/include/sys/user.h" 3 4
struct user_fpregs_struct
{
  long cwd;
  long swd;
  long twd;
  long fip;
  long fcs;
  long foo;
  long fos;
  long st_space [20];
};

struct user_regs_struct
{
  long ebx;
  long ecx;
  long edx;
  long esi;
  long edi;
  long ebp;
  long eax;
  long xds;
  long xes;
  long xfs;
  long xgs;
  long orig_eax;
  long eip;
  long xcs;
  long eflags;
  long esp;
  long xss;
};

struct user
{
  struct user_regs_struct regs;
  int u_fpvalid;
  struct user_fpregs_struct i387;
  unsigned long int u_tsize;
  unsigned long int u_dsize;
  unsigned long int u_ssize;
  unsigned long start_code;
  unsigned long start_stack;
  long int signal;
  int reserved;
  struct user_regs_struct* u_ar0;
  struct user_fpregs_struct* u_fpstate;
  unsigned long magic;
  char u_comm [32];
  int u_debugreg [8];
};
# 32 "/usr/include/sys/ucontext.h" 2 3 4



typedef int greg_t;





typedef greg_t gregset_t[19];



enum
{
  REG_GS = 0,

  REG_FS,

  REG_ES,

  REG_DS,

  REG_EDI,

  REG_ESI,

  REG_EBP,

  REG_ESP,

  REG_EBX,

  REG_EDX,

  REG_ECX,

  REG_EAX,

  REG_TRAPNO,

  REG_ERR,

  REG_EIP,

  REG_CS,

  REG_EFL,

  REG_UESP,

  REG_SS

};



struct _libc_fpreg
{
  unsigned short int significand[4];
  unsigned short int exponent;
};

struct _libc_fpstate
{
  unsigned long int cw;
  unsigned long int sw;
  unsigned long int tag;
  unsigned long int ipoff;
  unsigned long int cssel;
  unsigned long int dataoff;
  unsigned long int datasel;
  struct _libc_fpreg _st[8];
  unsigned long int status;
};


typedef struct _libc_fpstate *fpregset_t;


typedef struct
  {
    gregset_t gregs;


    fpregset_t fpregs;
    unsigned long int oldmask;
    unsigned long int cr2;
  } mcontext_t;


typedef struct ucontext
  {
    unsigned long int uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    __sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
  } ucontext_t;
# 28 "/usr/include/ucontext.h" 2 3 4

extern "C" {


extern int getcontext (ucontext_t *__ucp) throw ();


extern int setcontext (__const ucontext_t *__ucp) throw ();



extern int swapcontext (ucontext_t *__oucp, __const ucontext_t *__ucp) throw ();







extern void makecontext (ucontext_t *__ucp, void (*__func) (void), int __argc, ...) throw ();


}
# 318 "/usr/include/signal.h" 2 3 4





extern int sigstack (struct sigstack *__ss, struct sigstack *__oss) throw ();



extern int sigaltstack (__const struct sigaltstack *__ss, struct sigaltstack *__oss) throw ();
# 336 "/usr/include/signal.h" 3 4
extern int sighold (int __sig) throw ();


extern int sigrelse (int __sig) throw ();


extern int sigignore (int __sig) throw ();


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();



# 1 "/usr/include/bits/sigthread.h" 1 3 4
# 350 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) throw ();

extern int __libc_current_sigrtmax (void) throw ();



}
# 247 "../include/mico/os-net.h" 2
# 260 "../include/mico/os-net.h"
class OSNet {
# 276 "../include/mico/os-net.h"
public:
    static void set_errno ()
    {
    }

    static void sock_init ()
    {

        signal (13, ((__sighandler_t) 1));
    }

    static void sock_block (MICO_Long fd, MICO_Boolean on)
    {
        CORBA::Long flags = fcntl (fd, 3, 0);
        ((void) ((flags != -1) ? 0 : (__assert_fail ("flags != -1", "../include/mico/os-net.h", 290, __PRETTY_FUNCTION__), 0)));
        flags = on ? (flags & ~04000) : (flags | 04000);
        fcntl (fd, 4, flags);
    }

    static void sock_reuse (MICO_Long fd, MICO_Boolean on)
    {
        int _on = on;
        ::setsockopt (fd, 1, 2, (char *)&_on, sizeof(_on));
    }

    static void sock_broadcast (MICO_Long fd, MICO_Boolean on)
    {
        int _on = on;
        ::setsockopt (fd, 1, 6, (char *)&_on, sizeof(_on));
    }

    static void sock_ndelay (MICO_Long fd, MICO_Boolean on)
    {

        int _on = on;
        ::setsockopt (fd, IPPROTO_TCP, 0x01, (char *)&_on, sizeof(_on));

    }

    static MICO_Long sock_read (MICO_Long fd, void *buf, MICO_ULong count)
    {






        return ::read (fd, buf, count);
    }

    static MICO_Long sock_read_from (MICO_Long fd, void *buf,
                                     MICO_ULong count,
                                     struct sockaddr *sa,
                                     MICO_ULong sa_count)
    {






        socklen_t fromlen = sa_count;
        return ::recvfrom (fd, (char *)buf, count, 0,
                           (struct sockaddr *)sa, &fromlen);
    }

    static MICO_Long sock_write (MICO_Long fd, const void *buf,
                                 MICO_ULong count)
    {
        return ::write (fd, buf, count);
    }

    static MICO_Long sock_write_to (MICO_Long fd, const void *buf,
                                    MICO_ULong count,
                                    const struct sockaddr *sa,
                                    MICO_ULong sa_count)
    {
        return ::sendto (fd, (char *)buf, count, 0,
                         (struct sockaddr *)sa, sa_count);
    }

    static MICO_Long sock_close (MICO_Long fd)
    {
        return ::close (fd);
    }
};
# 31 "address.cc" 2
# 1 "../include/mico/impl.h" 1
# 27 "../include/mico/impl.h"
# 1 "../include/mico/util.h" 1
# 27 "../include/mico/util.h"
# 1 "/usr/include/ctype.h" 1 3 4
# 28 "../include/mico/util.h" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 29 "../include/mico/util.h" 2
# 1 "/opt/gcc3/include/g++-v3/fstream.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/fstream.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/basic_file.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/basic_file.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/basic_file.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/basic_file.h" 2 3

namespace std {







  template<typename _CharT>
  struct __basic_file_base: public __c_file_type
  {
    virtual
    ~__basic_file_base() { };

    virtual int
    overflow(int __c = (-1)) = 0;

    virtual int
    underflow() = 0;

    virtual int
    uflow() = 0;

    virtual int
    pbackfail(int __c) = 0;

    virtual streamsize
    xsputn(const _CharT* __s, streamsize __n) = 0;

    virtual streamsize
    xsgetn(_CharT* __s, streamsize __n) = 0;

    virtual streamoff
    seekoff(streamoff __off, ios_base::seekdir __way,
            ios_base::openmode __mode = ios_base::in | ios_base::out) = 0;

    virtual streamoff
    seekpos(streamoff __pos,
            ios_base::openmode __mode = ios_base::in | ios_base::out) = 0;

    virtual streambuf*
    setbuf(_CharT* __b, int __len) = 0;

    virtual int
    sync() = 0;

    virtual int
    doallocate() = 0;

    virtual streamsize
    sys_read(_CharT* __s, streamsize __n) = 0;

    virtual streamsize
    sys_write(const _CharT* __s, streamsize __n) = 0;

    virtual streamoff
    sys_seek(streamoff __off, ios_base::seekdir __way) = 0;

    virtual int
    sys_close() = 0;

    virtual int
    sys_stat(void* __v) = 0;

    virtual int
    showmanyc() = 0;

    virtual void
    imbue(void* __v) = 0;
  };




  template<typename _CharT>



    class __basic_file

    {

      int _M_fileno;
      __c_file_type* _M_cfile;





    public:
      __basic_file(__c_lock* __lock = 0);

      void
      _M_open_mode(ios_base::openmode __mode, int& __p_mode, int& __rw_mode,
                   char* __c_mode);


      __basic_file*
      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);





      __basic_file*
      sys_open(int __fd, ios_base::openmode __mode);

      __basic_file*
      close();

      bool
      is_open();


      int get_fileno(void);





      virtual
      ~__basic_file();

      virtual int
      overflow(int __c = (-1));

      virtual int
      underflow();

      virtual int
      uflow();

      virtual int
      pbackfail(int __c);




      virtual streamsize
      xsputn(const _CharT* __s, streamsize __n);




      virtual streamsize
      xsgetn(_CharT* __s, streamsize __n);




      virtual streamoff
      seekoff(streamoff __off, ios_base::seekdir __way,
              ios_base::openmode __mode = ios_base::in | ios_base::out);




      virtual streamoff
      seekpos(streamoff __pos,
              ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual streambuf*
      setbuf(_CharT* __b, int __len);

      virtual int
      sync();

      virtual int
      doallocate();




      virtual streamsize
      sys_read(_CharT* __s, streamsize __n);




      virtual streamsize
      sys_write(const _CharT* __s, streamsize __n);




      virtual streamoff
      sys_seek(streamoff __off, ios_base::seekdir __way);

      virtual int
      sys_close();

      virtual int
      sys_stat(void* __v);

      virtual int
      showmanyc();

      virtual void
      imbue(void* __v);
    };
}
# 40 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_locale.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_locale.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/localefwd.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_locale.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ctime.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_ctime.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_ctime.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_ctime.h" 2 3


# 1 "/usr/include/time.h" 1 3 4
# 44 "/opt/gcc3/include/g++-v3/bits/std_ctime.h" 2 3



namespace std
{
  using ::clock_t;
  using ::time_t;
  using ::tm;

  extern "C" clock_t clock(void);
  extern "C" double difftime(time_t, time_t);
  extern "C" time_t mktime(struct tm*);
  extern "C" time_t time(time_t*);
  extern "C" char* asctime(const struct tm*);
  extern "C" char* ctime(const time_t*);
  extern "C" struct tm* gmtime(const time_t*);
  extern "C" struct tm* localtime(const time_t*);
  extern "C" size_t strftime(char*, size_t, const char*, const struct tm*);
}
# 40 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/typeinfo" 1 3
# 38 "/opt/gcc3/include/g++-v3/typeinfo" 3
#pragma interface "typeinfo"

# 1 "/opt/gcc3/include/g++-v3/exception" 1 3
# 41 "/opt/gcc3/include/g++-v3/typeinfo" 2 3

extern "C++" {


namespace __cxxabiv1
{
  class __class_type_info;
}


namespace std
{
  class type_info
  {
  public:




    virtual ~type_info();

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);

  protected:
    const char *__name;

  protected:
    explicit type_info(const char *__n): __name(__n) { }

  public:
# 89 "/opt/gcc3/include/g++-v3/typeinfo" 3
    bool before(const type_info& __arg) const
    { return __name < __arg.__name; }
    const char* name() const
    { return __name; }
    bool operator==(const type_info& __arg) const
    { return __name == __arg.__name; }
    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }




  public:

    virtual bool __is_pointer_p() const;

    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
                            unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
                             void **__obj_ptr) const;

  };

  class bad_cast : public exception
  {
  public:
    bad_cast() throw() { }
    virtual ~bad_cast() throw() { }
  };

  class bad_typeid : public exception
  {
  public:
    bad_typeid () throw() { }
    virtual ~bad_typeid () throw() { }
  };
}

}
# 41 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3






namespace std
{







  struct _Bad_use_facet : public bad_cast
  {
    _Bad_use_facet() throw() {}

    _Bad_use_facet(_Bad_use_facet const& __b) throw()
    : bad_cast(__b) { }

    _Bad_use_facet&
    operator=(_Bad_use_facet const& __b) throw()
    {
      static_cast<bad_cast*>(this)->operator=(__b);
      return *this;
    }

    virtual char const*
    what() const throw();

    virtual
    ~_Bad_use_facet() throw();
  };

  template<typename _Facet>
    const _Facet&
    _Use_facet_failure_handler(const locale&)
    { throw _Bad_use_facet(); }



# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/ctype_base.h" 1 3
# 50 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/ctype_base.h" 3
  struct ctype_base
  {

    typedef const int* __to_type;



    typedef unsigned short mask;
    static const mask upper = _ISupper;
    static const mask lower = _ISlower;
    static const mask alpha = _ISalpha;
    static const mask digit = _ISdigit;
    static const mask xdigit = _ISxdigit;
    static const mask space = _ISspace;
    static const mask print = _ISprint;
    static const mask graph = _ISgraph;
    static const mask cntrl = _IScntrl;
    static const mask punct = _ISpunct;
    static const mask alnum = _ISalnum;
  };
# 86 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:

      typedef _CharT char_type;

      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }

      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }

      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }

      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }

      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }

      const char_type*
      toupper(char_type *__low, const char_type* __high) const
      { return this->do_toupper(__low, __high); }

      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }

      const char_type*
      tolower(char_type* __low, const char_type* __high) const
      { return this->do_tolower(__low, __high); }

      char_type
      widen(char __c) const
      { return this->do_widen(__c); }

      const char*
      widen(const char* __low, const char* __high, char_type* __to) const
      { return this->do_widen(__low, __high, __to); }

      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }

      const char_type*
      narrow(const char_type* __low, const char_type* __high,
              char __dfault, char *__to) const
      { return this->do_narrow(__low, __high, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): locale::facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }

      virtual bool
      do_is(mask __m, char_type __c) const = 0;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
            mask* __vec) const = 0;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
                 const char_type* __hi) const = 0;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const = 0;

      virtual char_type
      do_toupper(char_type) const = 0;

      virtual const char_type*
      do_toupper(char_type* __low, const char_type* __high) const = 0;

      virtual char_type
      do_tolower(char_type) const = 0;

      virtual const char_type*
      do_tolower(char_type* __low, const char_type* __high) const = 0;

      virtual char_type
      do_widen(char) const = 0;

      virtual const char*
      do_widen(const char* __low, const char* __high,
               char_type* __dest) const = 0;

      virtual char
      do_narrow(char_type, char __dfault) const = 0;

      virtual const char_type*
      do_narrow(const char_type* __low, const char_type* __high,
                 char __dfault, char* __dest) const = 0;
    };


  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename ctype::mask mask;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

      static locale::id id;

   protected:
      virtual
      ~ctype() { }
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;


  template<>
    class ctype<char> : public __ctype_abstract_base<char>
    {
    public:

      typedef char char_type;

    private:

      bool _M_del;
      __to_type const& _M_toupper;
      __to_type const& _M_tolower;
      const mask* const& _M_ctable;
      const mask* _M_table;

    public:
      static locale::id id;
      static const size_t table_size = 1 + static_cast<unsigned char>(-1);

      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);

      inline bool
      is(mask __m, char __c) const;

      inline const char*
      is(const char* __low, const char* __high, mask* __vec) const;

      inline const char*
      scan_is(mask __m, const char* __low, const char* __high) const;

      inline const char*
      scan_not(mask __m, const char* __low, const char* __high) const;

    protected:
      virtual
      ~ctype();

      const mask*
      table() const throw()
      { return _M_table; }

      const mask*
      classic_table() throw()
      { return _M_ctable; }

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
            mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
                 const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
                  const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type) const;

      virtual const char_type*
      do_toupper(char_type* __low, const char_type* __high) const;

      virtual char_type
      do_tolower(char_type) const;

      virtual const char_type*
      do_tolower(char_type* __low, const char_type* __high) const;

      virtual char_type
      do_widen(char) const;

      virtual const char*
      do_widen(const char* __low, const char* __high,
               char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __low, const char_type* __high,
                 char __dfault, char* __dest) const;
    };

  template<>
    const ctype<char>&
    use_facet<ctype<char> >(const locale& __loc);
# 380 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/ctype_inline.h" 1 3
# 37 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/ctype_inline.h" 3
  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[__c] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[*__low++];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high && !(_M_table[*__low] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
           && (_M_table[*__low] & __m) != 0)
      ++__low;
    return __low;
  }
# 381 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef _CharT char_type;

      explicit
      ctype_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname() { }
    };


  template<>
    ctype_byname<char>::ctype_byname(const char*, size_t refs);



# 1 "/opt/gcc3/include/g++-v3/bits/codecvt.h" 1 3
# 171 "/opt/gcc3/include/g++-v3/bits/codecvt.h" 3
  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };





  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;


      result
      out(state_type& __state, const intern_type* __from,
          const intern_type* __from_end, const intern_type*& __from_next,
          extern_type* __to, extern_type* __to_end,
          extern_type*& __to_next) const
      {
        return this->do_out(__state, __from, __from_end, __from_next,
                            __to, __to_end, __to_next);
      }

      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
              extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }

      result
      in(state_type& __state, const extern_type* __from,
         const extern_type* __from_end, const extern_type*& __from_next,
         intern_type* __to, intern_type* __to_end,
         intern_type*& __to_next) const
      {
        return this->do_in(__state, __from, __from_end, __from_next,
                           __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(const state_type& __state, const extern_type* __from,
             const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
            intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(const state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const = 0;

      virtual int
      do_max_length() const throw() = 0;
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT,_ExternT,_StateT> (__refs) { }

    protected:
      virtual
      ~codecvt() { }
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
# 592 "/opt/gcc3/include/g++-v3/bits/codecvt.h" 3
  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
             const intern_type* __from_end, const intern_type*& __from_next,
             extern_type* __to, extern_type* __to_end,
             extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
                 extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
            const extern_type* __from_end, const extern_type*& __from_next,
            intern_type* __to, intern_type* __to_end,
            intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(const state_type&, const extern_type* __from,
                const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };
# 698 "/opt/gcc3/include/g++-v3/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs) { }
    protected:
      virtual
      ~codecvt_byname() { }
    };
# 404 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 2 3

  template<typename _CharT, typename _InIter>
    class _Numeric_get;






  template<typename _CharT>
    class _Format_cache
    {
    public:

      typedef _CharT char_type;
      typedef char_traits<_CharT> traits_type;
      typedef basic_string<_CharT> string_type;
      typedef typename string_type::size_type size_type;


      friend class locale;
      template<typename _Char, typename _InIter>
        friend class _Numeric_get;
      friend class num_get<_CharT>;
      friend class num_put<_CharT>;
      friend class time_get<_CharT>;
      friend class money_get<_CharT>;
      friend class time_put<_CharT>;
      friend class money_put<_CharT>;




      static int _S_pword_ix;



      bool _M_valid;



      static const char _S_literals[];




      enum
      {
        _S_minus,
        _S_plus,
        _S_x,
        _S_X,
        _S_digits,
        _S_digits_end = _S_digits + 16,
        _S_udigits = _S_digits_end,
        _S_udigits_end = _S_udigits + 16,
        _S_ee = _S_digits + 14,
        _S_Ee = _S_udigits + 14
      };




      char_type _M_decimal_point;





      char_type _M_thousands_sep;



      string_type _M_truename;
      string_type _M_falsename;



      bool _M_use_grouping;



      string _M_grouping;

      _Format_cache();

      ~_Format_cache() throw() { }




      static _Format_cache<_CharT>*
      _S_get(ios_base& __ios);

      void
      _M_populate(ios_base&);

      static void
      _S_callback(ios_base::event __event, ios_base& __ios, int __ix) throw();
    };

  template<typename _CharT>
    int _Format_cache<_CharT>::_S_pword_ix;

  template<typename _CharT>
    const char _Format_cache<_CharT>::
    _S_literals[] = "-+xX0123456789abcdef0123456789ABCDEF";

   template<> _Format_cache<char>::_Format_cache();






  template<typename _CharT, typename _InIter>
    class _Numeric_get
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;


      template<typename _Char, typename _InIterT>
      friend class num_get;
      template<typename _Char, typename _InIterT>
      friend class time_get;
      template<typename _Char, typename _InIterT>
      friend class money_get;
      template<typename _Char, typename _InIterT>
      friend class num_put;
      template<typename _Char, typename _InIterT>
      friend class time_put;
      template<typename _Char, typename _InIterT>
      friend class money_put;

    private:
      explicit
      _Numeric_get() { }

      virtual
      ~_Numeric_get() { }

      iter_type
      _M_get_digits(iter_type __in, iter_type __end) const;
    };

  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef char_traits<_CharT> __traits_type;

      static locale::id id;

      explicit
      num_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, bool& __v) const
      { return do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, short& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, int& __v) const
      { return do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long& __v) const
      { return do_get(__in, __end, __io, __err, __v); }
# 595 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned short& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned int& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, unsigned long& __v) const
      { return do_get(__in, __end, __io, __err, __v); }
# 617 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, float& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, double& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, long double& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
          ios_base::iostate& __err, void*& __v) const
      { return do_get(__in, __end, __io, __err, __v); }

    protected:
      virtual ~num_get() { }





      void
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
                 ios_base::iostate& __err, char* __xtrc,
                 int& __base, bool __fp = true) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, short&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, int&) const;

      virtual iter_type
      do_get (iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const;





      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
              unsigned short&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
              ios_base::iostate& __err, unsigned int&) const;
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
              ios_base::iostate& __err, unsigned long&) const;





      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             double&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&,
             ios_base::iostate& __err, long double&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
             void*&) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;


  template<>
    void
    num_get<char, istreambuf_iterator<char> >::
    _M_extract(istreambuf_iterator<char> __beg,
               istreambuf_iterator<char> __end, ios_base& __io,
               ios_base::iostate& __err, char* __xtrc,
               int& __base, bool __fp) const;



  template<typename _CharT, typename _OutIter>
    class _Numeric_put
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;
    protected:
      explicit
      _Numeric_put() { }

      virtual
      ~_Numeric_put() { }
    };

  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      static locale::id id;

      explicit
      num_put(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          unsigned long __v) const
      { return do_put(__s, __f, __fill, __v); }
# 761 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          long double __v) const
      { return do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          const void* __v) const
      { return do_put(__s, __f, __fill, __v); }

    protected:
      virtual
      ~num_put() { };

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, long __v) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, unsigned long) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, double __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, long double __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;

  template<typename _CharT>
    class _Punct : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      char_type
      decimal_point() const
      { return do_decimal_point(); }

      char_type
      thousands_sep() const
      { return do_thousands_sep(); }

      string
      grouping() const
      { return do_grouping(); }
    protected:

      explicit
      _Punct(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~_Punct() { }

      virtual char_type
      do_decimal_point() const
      { return _M_decimal_point; }

      virtual char_type
      do_thousands_sep() const
      { return _M_thousands_sep; }

      virtual string
      do_grouping() const
      { return _M_grouping; }

    private:
      char_type _M_decimal_point;
      char_type _M_thousands_sep;
      string _M_grouping;

    protected:

      void
      _M_init(char_type __d, char_type __t, const string& __g)
      {
        _M_decimal_point = __d;
        _M_thousands_sep = __t;
        _M_grouping = __g;
      }
    };

  template<typename _CharT>
    class _Numpunct : public _Punct<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      string_type
      truename() const
      { return do_truename(); }

      string_type
      falsename() const
      { return do_falsename(); }

    protected:
      explicit
      _Numpunct(size_t __refs = 0) : _Punct<_CharT> (__refs) { }

      virtual
      ~_Numpunct() { }

      virtual string_type
      do_truename() const
      { return _M_truename; }

      virtual string_type
      do_falsename() const
      { return _M_falsename; }

    private:
      string_type _M_truename;
      string_type _M_falsename;

    protected:

      void
      _M_boolnames_init(const string_type& __t, const string_type& __f)
      {
        _M_truename = __t;
        _M_falsename = __f;
      }
    };

  template<typename _CharT>
    class numpunct : public _Numpunct<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      numpunct(size_t __refs = 0) : _Numpunct<_CharT>(__refs) { }

    protected:
      virtual
      ~numpunct() { }
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<>
    numpunct<char>::numpunct(size_t __refs): _Numpunct<char>(__refs)
    {
      _M_init('.', ',', "");
      _M_boolnames_init("true", "false");
    }
# 947 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    class numpunct_byname : public numpunct<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~numpunct_byname() { }
    };

  template<>
    numpunct_byname<char>::numpunct_byname(const char*, size_t __refs);





  template<typename _CharT>
    class _Collate : public locale::facet
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
              const _CharT* __lo2, const _CharT* __hi2) const
      { return do_compare(__lo1, __hi1, __lo2, __hi2); }

      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return do_transform(__lo, __hi); }

      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return do_hash(__lo, __hi); }

  protected:
      explicit
      _Collate(size_t __refs = 0) : locale::facet(__refs) { }

      ~_Collate() { }

      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
                 const _CharT* __lo2, const _CharT* __hi2) const = 0;

      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const = 0;

      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const = 0;
    };

  template<typename _CharT>
    class collate : public _Collate<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      collate(size_t __refs = 0) : _Collate<_CharT> (__refs) { }

      static locale::id id;

    protected:
      virtual
      ~collate() { }
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;

  template<>
    class collate<char> : public _Collate<char>
    {
    public:

      typedef char char_type;
      typedef basic_string<char> string_type;

      explicit
      collate(size_t __refs = 0);

      static locale::id id;

    protected:
      virtual
      ~collate();

      virtual int
      do_compare(const char* __lo1, const char* __hi1,
                 const char* __lo2, const char* __hi2) const;

      virtual string_type
      do_transform(const char* __lo, const char* __hi) const;

      virtual long
      do_hash(const char* __lo, const char* __hi) const;
    };
# 1086 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    class collate_byname : public collate<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      collate_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~collate_byname() { }
    };

  template<>
    collate_byname<char>::collate_byname(const char*, size_t __refs);





  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      static locale::id id;

      explicit
      time_get(size_t __refs = 0)
      : locale::facet (__refs), _M_daynames(0), _M_monthnames(0) { }

      dateorder
      date_order() const
      { return do_date_order(); }

      iter_type
      get_time(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_time(__s, __end, __f, __err, __t); }

      iter_type
      get_date(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_date(__s, __end, __f, __err, __t); }

      iter_type
      get_weekday(iter_type __s, iter_type __end, ios_base& __f,
                  ios_base::iostate& __err, tm* __t) const
      { return do_get_weekday(__s,__end,__f,__err,__t); }

      iter_type
      get_monthname(iter_type __s, iter_type __end, ios_base& __f,
                    ios_base::iostate& __err, tm* __t) const
      { return do_get_monthname(__s,__end,__f,__err,__t); }

      iter_type
      get_year(iter_type __s, iter_type __end, ios_base& __f,
               ios_base::iostate& __err, tm* __t) const
      { return do_get_year(__s,__end,__f,__err,__t); }

    protected:
      virtual
      ~time_get()
      {
        delete [] _M_monthnames;
        delete [] _M_daynames;
      }

      virtual dateorder
      do_date_order() const
      { return time_base::ymd; }

      virtual iter_type
      do_get_time(iter_type __s, iter_type , ios_base&,
                  ios_base::iostate& , tm* ) const
      { return __s; }

      virtual iter_type
      do_get_date(iter_type __s, iter_type , ios_base&,
                  ios_base::iostate& , tm* ) const
      { return __s; }

      virtual iter_type
      do_get_weekday(iter_type __s, iter_type __end, ios_base&,
                     ios_base::iostate& __err, tm* __t) const;

      virtual iter_type
      do_get_monthname(iter_type __s, iter_type __end, ios_base&,
                       ios_base::iostate& __err, tm* __t) const;

      virtual iter_type
      do_get_year(iter_type __s, iter_type , ios_base&,
                   ios_base::iostate& , tm* ) const
      { return __s; }

      mutable basic_string<_CharT>* _M_daynames;
      mutable basic_string<_CharT>* _M_monthnames;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:
      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }
    protected:
      virtual
      ~time_get_byname() { }
    };

  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet, public time_base
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;

      static locale::id id;

      explicit
      time_put(size_t __refs = 0) : locale::facet (__refs) { }


      iter_type
      put(iter_type __s, ios_base& , char_type ,
          const tm* , const _CharT* ,
          const _CharT* ) const
      { return __s; }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
          const tm* __tmb, char __format, char __modifier = 0) const
      { return do_put(__s, __f, __fill, __tmb, __format, __modifier); }

    protected:
      virtual
      ~time_put() { }

      virtual iter_type
      do_put(iter_type __s, ios_base&, char_type, const tm* ,
             char , char ) const
      { return __s; }
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;

  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter> (__refs) { }

    protected:
      virtual
      ~time_put_byname() { }
    };


  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:
      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_get(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl,
          ios_base& __f, ios_base::iostate& __err, long double& __units) const
      { return do_get(__s, __end, __intl, __f, __err, __units); }

      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __f,
           ios_base::iostate& __err, string_type& __digits) const
      { return do_get(__s, __end, __intl, __f, __err, __digits); }

    protected:
      virtual
      ~money_get() { }

      virtual iter_type
      do_get(iter_type __s, iter_type , bool ,
             ios_base& , ios_base::iostate& ,
             long double& ) const
      { return __s; }

      virtual iter_type
      do_get(iter_type __s, iter_type , bool ,
             ios_base& , ios_base::iostate& ,
             string_type& ) const
      { return __s; }
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;

  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:
      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;

      static locale::id id;

      explicit
      money_put(size_t __refs = 0) : locale::facet(__refs) { }

      iter_type
      put(iter_type __s, bool __intl, ios_base& __f,
          char_type __fill, long double __units) const
      { return do_put(__s, __intl, __f, __fill, __units); }

      iter_type
      put(iter_type __s, bool __intl, ios_base& __f,
          char_type __fill, const string_type& __digits) const
      { return do_put(__s, __intl, __f, __fill, __digits); }

    protected:
      virtual
      ~money_put() { }

      virtual iter_type
      do_put(iter_type __s, bool, ios_base& , char_type ,
             long double ) const
      { return __s; }

      virtual iter_type
      do_put(iter_type __s, bool, ios_base& , char_type ,
             const string_type& ) const
      { return __s; }
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;

  struct money_base
  {
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;
  };

  template<typename _CharT>
    class _Moneypunct : public _Punct<_CharT>, public money_base
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      string_type
      curr_symbol() const
      { return do_curr_symbol(); }

      string_type
      positive_sign() const
      { return do_positive_sign(); }

      string_type
      negative_sign() const
      { return do_negative_sign(); }

      int
      frac_digits() const
      { return do_frac_digits(); }

      pattern
      pos_format() const
      { return do_pos_format(); }

      pattern
      neg_format() const
      { return do_neg_format(); }

    protected:
      explicit
      _Moneypunct(size_t __refs = 0) : _Punct<_CharT> (__refs) { }

      virtual
      ~_Moneypunct() { }

      virtual string_type
      do_curr_symbol() const
      { return basic_string<_CharT>(); }

      virtual string_type
      do_positive_sign() const
      { return basic_string<_CharT>(); }

      virtual string_type
      do_negative_sign() const
      { return basic_string<_CharT>(); }

      virtual int
      do_frac_digits() const
      { return 0; }

      virtual pattern
      do_pos_format() const
      { return money_base::_S_default_pattern; }

      virtual pattern
      do_neg_format() const
      { return money_base::_S_default_pattern; }
    };

  template<typename _CharT, bool _Intl>
    class moneypunct : public _Moneypunct<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;
      static locale::id id;

      explicit
      moneypunct(size_t __refs = 0) : _Moneypunct<_CharT> (__refs) { }

    protected:
      virtual
      ~moneypunct() { }
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT,_Intl>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;
      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;

  template<>
    moneypunct_byname<char, false>::
    moneypunct_byname(const char*, size_t __refs);
  template<>
    moneypunct_byname<char, true>::
    moneypunct_byname(const char*, size_t __refs);
# 1483 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
  struct messages_base
  {
    typedef int catalog;
  };

  template<typename _CharT>
    class _Messages : public locale::facet, public messages_base
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return do_open(__s, __loc); }

      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return do_get(__c,__set,__msgid,__s); }

      void
      close(catalog __c) const
      { return do_close(__c); }

    protected:
      explicit
      _Messages(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~_Messages() { }



      virtual catalog
      do_open(const basic_string<char>&, const locale&) const
      { return 0; }

      virtual string_type
      do_get(catalog, int, int , const string_type& __dfault) const
      { return __dfault; }

      virtual void
      do_close (catalog) const { }
    };

  template<typename _CharT>
    class messages : public _Messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;
      static locale::id id;

      explicit
      messages(size_t __refs = 0) : _Messages<_CharT> (__refs) { }
    protected:
      virtual
      ~messages() { }
    };

  template<typename _CharT>
    locale::id messages<_CharT>::id;

  template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char*, size_t __refs = 0);

    protected:
      virtual
      ~messages_byname() { }
    };

  template<>
    messages_byname<char>::messages_byname(const char*, size_t __refs);
# 1572 "/opt/gcc3/include/g++-v3/bits/locale_facets.h" 3
  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }

  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }

  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }

  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }

  template<typename _CharT>
    inline bool islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }

  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }

  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }

  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }

  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }

  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }

  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }

  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }

  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
}
# 39 "/opt/gcc3/include/g++-v3/bits/std_locale.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 1 3
# 35 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cerrno.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_cerrno.h" 3
# 1 "/usr/include/errno.h" 1 3 4
# 41 "/opt/gcc3/include/g++-v3/bits/std_cerrno.h" 2 3

namespace std
{
  extern "C" int (*__errno_location ());
}
# 36 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_clocale.h" 1 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_clocale.h" 3
# 1 "/usr/include/locale.h" 1 3 4
# 26 "/usr/include/locale.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/locale.h" 2 3 4


# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4

extern "C" {
# 45 "/usr/include/locale.h" 3 4
struct lconv
{


  char *decimal_point;
  char *thousands_sep;





  char *grouping;





  char *int_curr_symbol;
  char *currency_symbol;
  char *mon_decimal_point;
  char *mon_thousands_sep;
  char *mon_grouping;
  char *positive_sign;
  char *negative_sign;
  char int_frac_digits;
  char frac_digits;

  char p_cs_precedes;

  char p_sep_by_space;

  char n_cs_precedes;

  char n_sep_by_space;






  char p_sign_posn;
  char n_sign_posn;
};



extern char *setlocale (int __category, __const char *__locale) throw ();


extern struct lconv *localeconv (void) throw ();
# 109 "/usr/include/locale.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 110 "/usr/include/locale.h" 2 3 4







extern __locale_t __newlocale (int __category_mask, __const char *__locale, __locale_t __base) throw ();





extern __locale_t __duplocale (__locale_t __dataset) throw ();



extern void __freelocale (__locale_t __dataset) throw ();


}
# 41 "/opt/gcc3/include/g++-v3/bits/std_clocale.h" 2 3

namespace std
{
  using ::lconv;
  extern "C" char* setlocale(int, const char*);
  extern "C" struct lconv* localeconv(void);
}
# 37 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstdlib.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/std_limits.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 1 3
# 18 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_algobase.h" 1 3
# 19 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_alloc.h" 1 3
# 20 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_construct.h" 1 3
# 21 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_iterator_base.h" 1 3
# 22 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_tempbuf.h" 1 3
# 23 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_uninitialized.h" 1 3
# 24 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_raw_storage_iter.h" 1 3
# 34 "/opt/gcc3/include/g++-v3/bits/stl_raw_storage_iter.h" 3
namespace std {

template <class _ForwardIterator, class _Tp>
class raw_storage_iterator {
protected:
  _ForwardIterator _M_iter;
public:
  typedef output_iterator_tag iterator_category;
  typedef void value_type;
  typedef void difference_type;
  typedef void pointer;
  typedef void reference;

  explicit raw_storage_iterator(_ForwardIterator __x) : _M_iter(__x) {}
  raw_storage_iterator& operator*() { return *this; }
  raw_storage_iterator& operator=(const _Tp& __element) {
    construct(&*_M_iter, __element);
    return *this;
  }
  raw_storage_iterator<_ForwardIterator, _Tp>& operator++() {
    ++_M_iter;
    return *this;
  }
  raw_storage_iterator<_ForwardIterator, _Tp> operator++(int) {
    raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
    ++_M_iter;
    return __tmp;
  }
};
# 75 "/opt/gcc3/include/g++-v3/bits/stl_raw_storage_iter.h" 3
}
# 25 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 2 3

namespace std {




 template<class _Tp1> struct auto_ptr_ref {
   _Tp1* _M_ptr;
   auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
};



template <class _Tp> class auto_ptr {
private:
  _Tp* _M_ptr;

public:
  typedef _Tp element_type;

  explicit auto_ptr(_Tp* __p = 0) throw() : _M_ptr(__p) {}
  auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) {}


  template <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) throw()
    : _M_ptr(__a.release()) {}


  auto_ptr& operator=(auto_ptr& __a) throw() {
    reset(__a.release());
    return *this;
  }


  template <class _Tp1>
  auto_ptr& operator=(auto_ptr<_Tp1>& __a) throw() {
    reset(__a.release());
    return *this;
  }






  ~auto_ptr() { delete _M_ptr; }

  _Tp& operator*() const throw() {
    return *_M_ptr;
  }
  _Tp* operator->() const throw() {
    return _M_ptr;
  }
  _Tp* get() const throw() {
    return _M_ptr;
  }
  _Tp* release() throw() {
    _Tp* __tmp = _M_ptr;
    _M_ptr = 0;
    return __tmp;
  }
  void reset(_Tp* __p = 0) throw() {
    if (__p != _M_ptr) {
      delete _M_ptr;
      _M_ptr = __p;
    }
  }
# 101 "/opt/gcc3/include/g++-v3/bits/std_memory.h" 3
public:
  auto_ptr(auto_ptr_ref<_Tp> __ref) throw()
    : _M_ptr(__ref._M_ptr) {}

  auto_ptr& operator=(auto_ptr_ref<_Tp> __ref) throw() {
    if (__ref._M_ptr != this->get()) {
      delete _M_ptr;
      _M_ptr = __ref._M_ptr;
    }
    return *this;
  }

  template <class _Tp1> operator auto_ptr_ref<_Tp1>() throw()
    { return auto_ptr_ref<_Tp>(this->release()); }
  template <class _Tp1> operator auto_ptr<_Tp1>() throw()
    { return auto_ptr<_Tp1>(this->release()); }


};

}
# 40 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/sbuf_iter.h" 1 3
# 41 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cctype.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_vector.h" 1 3
# 43 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 2 3

namespace std
{
  template<typename _Facet>
    locale
    locale::combine(const locale& __other)
    {
      locale __copy(*this);
      __copy._M_impl->_M_replace_facet(__other._M_impl, &_Facet::id);
      __copy._M_impl->_M_has_name = false;
      return __copy;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
                       const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {


      typedef std::collate<_CharT> __collate_type;
      const __collate_type* __fcoll = &use_facet<__collate_type>(*this);
      return (__fcoll->compare(__s1.data(), __s1.data() + __s1.length(),
                               __s2.data(), __s2.data() + __s2.length()) < 0);
    }

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      typedef locale::_Impl::__vec_facet __vec_facet;
      locale::id& __id = _Facet::id;
      size_t __i = __id._M_index;
      __vec_facet* __facet = __loc._M_impl->_M_facets;
      const locale::facet* __fp = (*__facet)[__i];
      if (__i >= __facet->size() || __fp == 0)
        return _Use_facet_failure_handler<_Facet>(__loc);
      return static_cast<const _Facet&>(*__fp);
    }

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      typedef locale::_Impl::__vec_facet __vec_facet;
      locale::id& __id = _Facet::id;
      size_t __i = __id._M_index;
      __vec_facet* __facet = __loc._M_impl->_M_facets;
      return (__i < __facet->size() && (*__facet)[__i] != 0);
    }







  template<typename _InIter, typename _CharT>
    _InIter
    __match_parallel(_InIter __s, _InIter __end, int __ntargs,
                     const basic_string<_CharT>* __targets,
                     int* __matches, int& __remain, bool& __eof)
    {
      typedef basic_string<_CharT> __string_type;
      __eof = false;
      for (int __ti = 0; __ti < __ntargs; ++__ti)
        __matches[__ti] = __ti;
      __remain = __ntargs;
      size_t __pos = 0;
      do
        {
          {
            int __ti = 0;
            for (;__ti < __remain &&
                   __pos == __targets[__matches[__ti]].size(); ++__ti)
              { }
            if (__ti == __remain)
              {
                if (__pos == 0) __remain = 0;
                return __s;
              }
          }
          if (__s == __end)
            __eof = true;
          bool __matched = false;
          for (int __ti = 0; __ti < __remain; )
            {
              const __string_type& __target = __targets[__matches[__ti]];
              if (__pos < __target.size())
                {
                  if (__eof || __target[__pos] != *__s)
                    {
                      __matches[__ti] = __matches[--__remain];
                      continue;
                    }
                  __matched = true;
                }
              ++__ti;
            }
          if (__matched)
            {
              ++__s;
              ++__pos;
            }
          for (int __ti = 0; __ti < __remain;)
            {
              if (__pos > __targets[__matches[__ti]].size())
                {
                  __matches[__ti] = __matches[--__remain];
                  continue;
                }
              ++__ti;
            }
        }
      while (__remain);
      return __s;
    }

  template<typename _CharT>
    _Format_cache<_CharT>::_Format_cache()
    : _M_valid(true), _M_use_grouping(false)
    { }

  template<>
    _Format_cache<char>::_Format_cache();

  template<>
    _Format_cache<wchar_t>::_Format_cache();

  template<typename _CharT>
    void
    _Format_cache<_CharT>::_M_populate(ios_base& __io)
    {
      locale __loc = __io.getloc ();
      numpunct<_CharT> const& __np = use_facet<numpunct<_CharT> >(__loc);
      _M_truename = __np.truename();
      _M_falsename = __np.falsename();
      _M_thousands_sep = __np.thousands_sep();
      _M_decimal_point = __np.decimal_point();
      _M_grouping = __np.grouping();
      _M_use_grouping = _M_grouping.size() != 0 && _M_grouping.data()[0] != 0;
      _M_valid = true;
    }



  template<typename _CharT>
    void
    _Format_cache<_CharT>::
    _S_callback(ios_base::event __ev, ios_base& __ios, int __ix) throw()
    {
      void*& __p = __ios.pword(__ix);
      switch (__ev)
        {
        case ios_base::erase_event:
          delete static_cast<_Format_cache<_CharT>*> (__p); __p = 0;
          break;
        case ios_base::copyfmt_event:

          try {
            __p = new _Format_cache<_CharT>;
          }
          catch(...) {
          }
          break;
        case ios_base::imbue_event:
          static_cast<_Format_cache<_CharT>*>(__p)->_M_valid = false;
          break;
        }
    }

  template<typename _CharT>
    _Format_cache<_CharT>*
    _Format_cache<_CharT>::_S_get(ios_base& __ios)
    {
      if (!_S_pword_ix)
        _S_pword_ix = ios_base::xalloc();
      void*& __p = __ios.pword(_S_pword_ix);


      if (__p == 0)
        {
          auto_ptr<_Format_cache<_CharT> > __ap(new _Format_cache<_CharT>);
          __ios.register_callback(&_Format_cache<_CharT>::_S_callback,
                                  _S_pword_ix);
          __p = __ap.release();
        }
      _Format_cache<_CharT>* __ncp = static_cast<_Format_cache<_CharT>*>(__p);
      if (!__ncp->_M_valid)
        __ncp->_M_populate(__ios);

      return __ncp;
    }
# 256 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    void
    num_get<_CharT, _InIter>::
    _M_extract(_InIter , _InIter , ios_base& ,
               ios_base::iostate& , char* ,
               int& , bool ) const
    {

    }

  template<>
    void
    num_get<char, istreambuf_iterator<char> >::
    _M_extract(istreambuf_iterator<char> __beg,
               istreambuf_iterator<char> __end, ios_base& __io,
               ios_base::iostate& __err, char* __xtrc, int& __base,
               bool __fp) const;



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {

      if (!(__io.flags() & ios_base::boolalpha))
        {






          char __xtrc[32] = {'\0'};
          int __base;
          _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


          char* __sanity;
          (*__errno_location ()) = 0;
          long __l = strtol(__xtrc, &__sanity, __base);
          if (!(__err & ios_base::failbit)
              && __l <= 1
              && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
            __v = __l;
          else
            __err |= ios_base::failbit;
        }


      else
        {
          typedef _Format_cache<char_type> __fcache_type;
          __fcache_type* __fmt = __fcache_type::_S_get(__io);
          const char_type* __true = __fmt->_M_truename.c_str();
          const char_type* __false = __fmt->_M_falsename.c_str();
          const size_t __truelen = __traits_type::length(__true) - 1;
          const size_t __falselen = __traits_type::length(__false) - 1;

          for (size_t __pos = 0; __beg != __end; ++__pos)
            {
              char_type __c = *__beg++;
              bool __testf = __c == __false[__pos];
              bool __testt = __c == __true[__pos];
              if (!(__testf || __testt))
                {
                  __err |= ios_base::failbit;
                  break;
                }
              else if (__testf && __pos == __falselen)
                {
                  __v = 0;
                  break;
                }
              else if (__testt && __pos == __truelen)
                {
                  __v = 1;
                  break;
                }
            }
          if (__beg == __end)
            __err |= ios_base::eofbit;
        }

      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, short& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0
          && __l >= (-32767 -1) && __l <= 32767)
        __v = static_cast<short>(__l);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, int& __v) const
    {



      char __xtrc[32] = {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0
          && __l >= (-2147483647 -1) && __l <= 2147483647)
        __v = static_cast<int>(__l);
      else
        __err |= ios_base::failbit;

      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      long __l = strtol(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __l;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 456 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned short& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0
          && __ul <= 65535)
        __v = static_cast<unsigned short>(__ul);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned int& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0
          && __ul <= (2147483647 * 2U + 1))
        __v = static_cast<unsigned int>(__ul);
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, unsigned long& __v) const
    {



      char __xtrc[32] = {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      unsigned long __ul = strtoul(__xtrc, &__sanity, __base);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __ul;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 564 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, float& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      char* __sanity;
      (*__errno_location ()) = 0;

      float __f = strtof(__xtrc, &__sanity);



      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __f;
      else
        __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      char* __sanity;
      (*__errno_location ()) = 0;
      double __d = strtod(__xtrc, &__sanity);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __d;
      else
        __err |= ios_base::failbit;

      return __beg;
    }


  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {



      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, true);


      char* __sanity;
      (*__errno_location ()) = 0;
      long double __ld = strtold(__xtrc, &__sanity);
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __ld;
      else
        __err |= ios_base::failbit;

      return __beg;
    }
# 684 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      fmtflags __fmt = __io.flags();
      fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
                             | ios_base::uppercase | ios_base::internal);
      __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));




      char __xtrc[32]= {'\0'};
      int __base;
      _M_extract(__beg, __end, __io, __err, __xtrc, __base, false);


      char* __sanity;
      (*__errno_location ()) = 0;
      void* __vp = reinterpret_cast<void*>(strtoul(__xtrc, &__sanity, __base));
      if (!(__err & ios_base::failbit)
          && __sanity != __xtrc && *__sanity == '\0' && (*__errno_location ()) == 0)
        __v = __vp;
      else
        __err |= ios_base::failbit;


      __io.flags(__fmt);
      return __beg;
    }


  template <typename _CharT, typename _OutIter>
    inline _OutIter
    _S_fill(_OutIter __s, _CharT __fill, int __padding);

  template <typename _CharT, typename _RaIter>
    _RaIter
    _S_fill(_RaIter __s, _CharT __fill, int __padding,
            random_access_iterator_tag)
    {
      fill_n(__s, __fill);
      return __s + __padding;
    }

  template <typename _CharT, typename _OutIter, typename _Tag>
    _OutIter
    _S_fill(_OutIter __s, _CharT __fill, int __padding, _Tag)
    {
      while (--__padding >= 0) { *__s = __fill; ++__s; }
      return __s;
    }

  template <typename _CharT, typename _OutIter>
    inline _OutIter
    _S_fill(_OutIter __s, _CharT __fill, int __padding)
    {
      return _S_fill(__s, __fill, __padding,
                     iterator_traits<_OutIter>::iterator_category());
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    _S_pad_numeric(_OutIter __s, ios_base::fmtflags ,
                   _CharT , int ,
                   _CharT const* , _CharT const* ,
                   _CharT const* )
    {

      return __s;
    }


  template <typename _CharT>
    ostreambuf_iterator<_CharT>
    _S_pad_numeric(ostreambuf_iterator<_CharT> __s, ios_base::fmtflags __flags,
                   _CharT __fill, int __width, _CharT const* __first,
                   _CharT const* __middle, _CharT const* __last)
    {
      typedef ostreambuf_iterator<_CharT> __out_iter;
      int __padding = __width - (__last - __first);
      if (__padding < 0)
        __padding = 0;
      ios_base::fmtflags __aflags = __flags & ios_base::adjustfield;
      bool __testfield = __padding == 0 || __aflags == ios_base::left
                         || __aflags == ios_base::internal;


      if (__first != __middle)
        {
          if (!__testfield)
            {
              _S_fill(__s, __fill, __padding);
              __padding = 0;
            }
          copy(__first, __middle, __s);
        }
      __out_iter __s2 = __s;

      if (__padding && __aflags != ios_base::left)
        {
          _S_fill(__s2, __fill, __padding);
          __padding = 0;
        }
      __out_iter __s3 = copy(__middle, __last, __s2);
      if (__padding)
        _S_fill(__s3, __fill, __padding);
      return __s3;
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      ios_base::fmtflags __flags = __io.flags();

      if ((__flags & ios_base::boolalpha) == 0)
        {
          unsigned long __uv = __v;
          return _S_format(__s, __io, __fill, false, __uv);
        }
      else
        {
          const char_type* __first;
          const char_type* __last;
          if (__v)
            {
              __first = __fmt->_M_truename.data();
              __last = __first + __fmt->_M_truename.size();
            }
          else
            {
              __first = __fmt->_M_falsename.data();
              __last = __first + __fmt->_M_falsename.size();
            }
          copy(__first, __last, __s);
        }
      return __s;
    }





  template <typename _CharT>
    _CharT*
    _S_group_digits(_CharT* __s, _CharT __grsep, char const* __grouping,
                    char const* __grend, _CharT const* __first,
                    _CharT const* __last)
    {
      if (__last - __first > *__grouping)
        {
          __s = _S_group_digits(__s, __grsep,
              (__grouping + 1 == __grend ? __grouping : __grouping + 1),
              __grend, __first, __last - *__grouping);
          __first = __last - *__grouping;
          *__s++ = __grsep;
        }
      do
        {
          *__s++ = *__first++;
        }
      while (__first != __last);
      return __s;
    }

  template <typename _CharT, typename _OutIter, typename _ValueT>
    _OutIter
    _S_format(_OutIter __s, ios_base& __io, _CharT __fill, bool __neg,
              _ValueT __v)
    {

      const long _M_room = numeric_limits<_ValueT>::digits10 * 2 + 4;
      _CharT __digits[_M_room];
      _CharT* __front = __digits + _M_room;
      ios_base::fmtflags __flags = __io.flags();
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      char const* __table = __fmt->_S_literals + __fmt->_S_digits;

      ios_base::fmtflags __basefield = (__flags & __io.basefield);
      _CharT* __sign_end = __front;
      if (__basefield == ios_base::hex)
        {
          if (__flags & ios_base::uppercase)
            __table += 16;
          do
            *--__front = __table[__v & 15];
          while ((__v >>= 4) != 0);
          __sign_end = __front;
          if (__flags & ios_base::showbase)
            {
              *--__front = __fmt->_S_literals[__fmt->_S_x +
                       ((__flags & ios_base::uppercase) ? 1 : 0)];
              *--__front = __table[0];
            }
        }
      else if (__basefield == ios_base::oct)
        {
          do
            *--__front = __table[__v & 7];
          while ((__v >>= 3) != 0);
          if (__flags & ios_base::showbase
              && static_cast<char>(*__front) != __table[0])
            *--__front = __table[0];
          __sign_end = __front;
        }
      else
        {

          do
            *--__front = __table[__v % 10];
          while ((__v /= 10) != 0);
          __sign_end = __front;

          if (__neg || (__flags & ios_base::showpos))
            *--__front = __fmt->_S_literals[__fmt->_S_plus - __neg];
        }


      if (!__fmt->_M_use_grouping && !__io.width())
        return copy(__front, __digits + _M_room, __s);

      if (!__fmt->_M_use_grouping)
        return _S_pad_numeric(__s, __flags, __fill, __io.width(0),
                              __front, __sign_end, __digits + _M_room);

      _CharT* __p = __digits;
      while (__front < __sign_end)
        *__p++ = *__front++;
      const char* __gr = __fmt->_M_grouping.data();
      __front = _S_group_digits(__p, __fmt->_M_thousands_sep, __gr,
        __gr + __fmt->_M_grouping.size(), __sign_end, __digits + _M_room);
      return _S_pad_numeric(__s, __flags, __fill, __io.width(0),
                            __digits, __p, __front);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    {
      unsigned long __uv = __v;
      bool __neg = false;
      if (__v < 0)
        {
          __neg = true;
          __uv = -__uv;
        }
      return _S_format(__s, __io, __fill, __neg, __uv);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long __v) const
    { return _S_format(__s, __io, __fill, false, __v); }
# 973 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    static _OutIter
    _S_output_float(_OutIter __s, ios_base& __io, _CharT __fill,
                    const char* __sptr, size_t __slen)
    {

      return __s;
    }


  template<typename _CharT>
    static ostreambuf_iterator<_CharT>
    _S_output_float(ostreambuf_iterator<_CharT> __s, ios_base& __io,
                    _CharT __fill, const char* __sptr, size_t __slen)
    {
      size_t __padding = __io.width() > streamsize(__slen) ?
                         __io.width() -__slen : 0;
      locale __loc = __io.getloc();
      ctype<_CharT> const& __ct = use_facet<ctype<_CharT> >(__loc);
      ios_base::fmtflags __adjfield = __io.flags() & ios_base::adjustfield;
      const char* const __eptr = __sptr + __slen;

      if (__adjfield == ios_base::internal)
       {

         if (__sptr < __eptr && (*__sptr == '+' || *__sptr == '-'))
           {
             __s = __ct.widen(*__sptr);
             ++__s;
             ++__sptr;
           }
         __s = _S_fill(__s, __fill, __padding);
         __padding = 0;
       }
      else if (__adjfield != ios_base::left)
        {
          __s = _S_fill(__s, __fill, __padding);
          __padding = 0;
        }

      char __decimal_point = *(localeconv()->decimal_point);
      const _Format_cache<_CharT>* __fmt = _Format_cache<_CharT>::_S_get(__io);
      for (; __sptr != __eptr; ++__s, ++__sptr)
       {

         if (*__sptr == __decimal_point)
           __s = __fmt->_M_decimal_point;

         else
           __s = __ct.widen(*__sptr);
       }

      if (__padding)
        _S_fill(__s, __fill, __padding);
      __io.width(0);
      return __s;
    }

  bool
  _S_build_float_format(ios_base& __io, char* __fptr, char __modifier,
                        streamsize __prec);

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    {
      const streamsize __max_prec = numeric_limits<double>::digits10 + 3;
      streamsize __prec = __io.precision();

      if (__prec > __max_prec)
        __prec = __max_prec;

      char __sbuf[__max_prec*2];
      size_t __slen;

      char __fbuf[16];
      if (_S_build_float_format(__io, __fbuf, 0, __prec))
        __slen = sprintf(__sbuf, __fbuf, __prec, __v);
      else
        __slen = sprintf(__sbuf, __fbuf, __v);

      return _S_output_float(__s, __io, __fill, __sbuf, __slen);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           long double __v) const
    {
      const streamsize __max_prec = numeric_limits<long double>::digits10 + 3;
      streamsize __prec = __io.precision();

      if (__prec > __max_prec)
        __prec = __max_prec;

      char __sbuf[__max_prec*2];
      size_t __slen;

      char __fbuf[16];

      if ( _S_build_float_format(__io, __fbuf, 'L', __prec))
        __slen = sprintf(__sbuf, __fbuf, __prec, __v);
      else
        __slen = sprintf(__sbuf, __fbuf, __v);

      return _S_output_float(__s, __io, __fill, __sbuf, __slen);
    }

  template <typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      typedef ios_base::fmtflags fmtflags;
      fmtflags __fmt = __io.flags();
      fmtflags __fmtmask = ~(ios_base::showpos | ios_base::basefield
                             | ios_base::uppercase | ios_base::internal);
      __io.flags(__fmt & __fmtmask | (ios_base::hex | ios_base::showbase));
      try {
        _OutIter __s2 = _S_format(__s, __io, __fill, false,
                                  reinterpret_cast<unsigned long>(__v));
        __io.flags(__fmt);
        return __s2;
      }
      catch (...) {
        __io.flags(__fmt);
        throw;
      }
    }





  template<typename _CharT, typename _Dummy = int>
    struct _Weekdaynames;

  template<typename _Dummy>
    struct _Weekdaynames<char, _Dummy>
    { static const char* const _S_names[14]; };

  template<typename _Dummy>
    const char* const
    _Weekdaynames<char, _Dummy>::_S_names[14] =
    {
      "Sun", "Sunday",
      "Mon", "Monday", "Tue", "Tuesday", "Wed", "Wednesday",
      "Thu", "Thursday", "Fri", "Friday", "Sat", "Saturday"
    };
# 1141 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Dummy = int>
    struct _Monthnames;

  template<typename _Dummy>
    struct _Monthnames<char,_Dummy>
    { static const char* const _S_names[24]; };

  template<typename _Dummy>
    const char* const
    _Monthnames<char,_Dummy>::_S_names[24] =
    {
      "Jan", "January", "Feb", "February", "Mar", "March",
      "Apr", "April", "May", "May", "Jun", "June",
      "Jul", "July", "Aug", "August", "Sep", "September",
      "Oct", "October", "Nov", "November", "Dec", "December"
    };
# 1174 "/opt/gcc3/include/g++-v3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __s, iter_type __end,
                   ios_base& __io, ios_base::iostate& __err, tm* __t) const
    {
      if (!_M_daynames)
        {
          _M_daynames = new basic_string<_CharT>[14];
          for (int __i = 0; __i < 14; ++__i)
            _M_daynames[__i] = _Weekdaynames<_CharT>::_S_names[__i];
        }
      bool __at_eof = false;
      int __remain = 0;
      int __matches[14];
      iter_type __out = __match_parallel(__s, __end, 14, _M_daynames,
                                         __matches, __remain, __at_eof);
      __err = ios_base::iostate(0);
      if (__at_eof) __err |= __io.eofbit;
      if (__remain == 1 ||
          __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1))
        __t->tm_wday = (__matches[0]>>1);
      else
        __err |= __io.failbit;
      return __out;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __s, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __t) const
    {
      if (!_M_monthnames)
        {
          _M_monthnames = new basic_string<_CharT>[24];
          for (int __i = 0; __i < 24; ++__i)
            _M_monthnames[__i] = _Monthnames<_CharT>::_S_names[__i];
        }
      bool __at_eof = false;
      int __remain = 0;
      int __matches[24];
      iter_type __out = __match_parallel( __s, __end, 24, _M_monthnames,
                                          __matches, __remain, __at_eof);
      __err = ios_base::iostate(0);
      if (__at_eof) __err |= __io.eofbit;
      if (__remain == 1 ||
          __remain == 2 && (__matches[0]>>1) == (__matches[1]>>1))
        __t->tm_mon = (__matches[0]>>1);
      else
        __err |= __io.failbit;
      return __out;
    }
}
# 40 "/opt/gcc3/include/g++-v3/bits/std_locale.h" 2 3
# 41 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 2 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++threads.h" 1 3
# 42 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 2 3

namespace std {

  template<typename _CharT, typename _Traits>
    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef __basic_file<char_type> __file_type;
      typedef typename traits_type::state_type __state_type;
      typedef codecvt<char_type, char, __state_type> __codecvt_type;
      typedef typename __codecvt_type::result __res_type;

      friend class ios_base;

    private:


      __file_type* _M_file;


      __state_type _M_state_cur;
      __state_type _M_state_beg;


      const __codecvt_type* _M_fcvt;


      __c_lock _M_lock;


      bool _M_last_overflowed;

    public:

      basic_filebuf();


      basic_filebuf(int __fd, const char* __name, ios_base::openmode __mode);

      virtual
      ~basic_filebuf()
      {
        this->close();
        _M_fcvt = __null;
        _M_last_overflowed = false;
      }


      bool
      is_open(void) const { return _M_file ? _M_file->is_open() : false; }

      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);

      __filebuf_type*
      close(void);

    protected:

      void
      _M_allocate_buffers();


      void
      _M_filebuf_init();


      virtual streamsize
      showmanyc(void);





      virtual int_type
      underflow(void);

      virtual int_type
      pbackfail(int_type __c = _Traits::eof());
# 140 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 3
      virtual int_type
      overflow(int_type __c = _Traits::eof());
# 150 "/opt/gcc3/include/g++-v3/bits/std_fstream.h" 3
      int_type
      _M_really_overflow(int_type __c = _Traits::eof());

      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
        if (!this->is_open() && __s == 0 && __n == 0)
          {
            _M_buf_size = 0;
            _M_buf_size_opt = 0;
          }
        _M_last_overflowed = false;
        return this;
      }

      virtual pos_type
      seekoff(off_type __off, ios_base::seekdir __way,
              ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual pos_type
      seekpos(pos_type __pos,
              ios_base::openmode __mode = ios_base::in | ios_base::out);

      virtual int
      sync(void)
      {
        bool __testput = _M_out_cur && _M_out_beg < _M_out_end;
        if (__testput)
          {


            _M_file->sync();





            streamoff __cur = _M_file->seekoff(0, ios_base::cur);
            off_type __off = _M_out_cur - _M_out_beg;
            _M_really_overflow();
            _M_file->seekpos(__cur + __off);
          }
        _M_last_overflowed = false;
        return 0;
      }

      virtual void
      imbue(const locale& __loc);

      virtual streamsize
      xsgetn(char_type* __s, streamsize __n)
      {
        streamsize __ret = 0;

        if (_M_pback_init)
          {
            while (__ret < __n && _M_in_cur < _M_in_end)
              {
                *__s = *_M_in_cur;
                ++__ret;
                ++__s;
                ++_M_in_cur;
              }
            _M_pback_destroy();
          }
        if (__ret < __n)
          __ret += __streambuf_type::xsgetn(__s, __n - __ret);
        return __ret;
      }

      virtual streamsize
      xsputn(const char_type* __s, streamsize __n)
      {
        _M_pback_destroy();
        return __streambuf_type::xsputn(__s, __n);
      }

      void
      _M_output_unshift();
    };



  template<typename _CharT, typename _Traits>
    class basic_ifstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;


      basic_ifstream()
      : __istream_type(new __filebuf_type())
      { }

      explicit
      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
      : __istream_type(new __filebuf_type())
      { this->open(__s, __mode); }

      ~basic_ifstream()
      {
        delete _M_streambuf;
        _M_streambuf = __null;
      }


      __filebuf_type*
      rdbuf() const
      { return static_cast<__filebuf_type*>(_M_streambuf); }

      bool
      is_open(void) { return rdbuf()->is_open(); }

      void
      open(const char* __s, ios_base::openmode __mode = ios_base::in)
      {
        if (rdbuf()->open(__s, __mode | ios_base::in) == __null)
          this->setstate(ios_base::failbit);
      }

      void
      close(void)
      {
        if (!rdbuf()->close())
          this->setstate(ios_base::failbit);
      }
    };



  template<typename _CharT, typename _Traits>
    class basic_ofstream : public basic_ostream<_CharT,_Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;


      basic_ofstream()
      : __ostream_type(new __filebuf_type())
      { }

      explicit
      basic_ofstream(const char* __s,
                     ios_base::openmode __mode = ios_base::out|ios_base::trunc)
      : __ostream_type(new __filebuf_type())
      { this->open(__s, __mode); }

      ~basic_ofstream()
      {
        delete _M_streambuf;
        _M_streambuf = __null;
      }


      __filebuf_type*
      rdbuf(void) const
      { return static_cast<__filebuf_type*>(_M_streambuf); }

      bool
      is_open(void) { return rdbuf()->is_open(); }

      void
      open(const char* __s,
           ios_base::openmode __mode = ios_base::out | ios_base::trunc)
      {
        if (!rdbuf()->open(__s, __mode | ios_base::out))
          this->setstate(ios_base::failbit);
      }

      void
      close(void)
      {
        if (!rdbuf()->close())
          setstate(ios_base::failbit);
      }
    };



  template<typename _CharT, typename _Traits>
    class basic_fstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ios<char_type, traits_type> __ios_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;


      basic_fstream()
      : __iostream_type(new __filebuf_type())
      { }

      explicit
      basic_fstream(const char* __s,
                    ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(new __filebuf_type())
      { this->open(__s, __mode); }

      ~basic_fstream()
      {
        delete _M_streambuf;
        _M_streambuf = __null;
      }


      __filebuf_type*
      rdbuf(void) const
      { return static_cast<__filebuf_type*>(_M_streambuf); }

      bool
      is_open(void) { return rdbuf()->is_open(); }

      void
      open(const char* __s,
           ios_base::openmode __mode = ios_base::in | ios_base::out)
      {
        if (!rdbuf()->open(__s, __mode))
          setstate (ios_base::failbit);
      }

      void
      close(void)
      {
        if (!rdbuf()->close())
          setstate (ios_base::failbit);
      }
    };

}
# 32 "/opt/gcc3/include/g++-v3/fstream.h" 2 3

using std::ifstream;
using std::ofstream;
using std::fstream;
# 30 "../include/mico/util.h" 2
# 1 "../include/CORBA.h" 1
# 31 "../include/mico/util.h" 2
# 1 "../include/mico/os-misc.h" 1
# 182 "../include/mico/os-misc.h"
# 1 "/usr/include/stdio.h" 1 3 4
# 183 "../include/mico/os-misc.h" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 184 "../include/mico/os-misc.h" 2
# 1 "/usr/include/signal.h" 1 3 4
# 185 "../include/mico/os-misc.h" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 186 "../include/mico/os-misc.h" 2
# 1 "/usr/include/sys/time.h" 1 3 4
# 187 "../include/mico/os-misc.h" 2





struct OSMisc {
    typedef long long longlong;
    typedef unsigned long long ulonglong;

    static void _init()
    {
    }

    typedef struct timeval TimeVal;

    static TimeVal gettime ()
    {
      struct timeval tv;

      gettimeofday (&tv, __null);



      return tv;
    }

    enum AccessMode {
        ACCESS_READ = 4,
        ACCESS_WRITE = 2,
        ACCESS_EXEC = 1
    };

    static MICO_Long access (const char *file, AccessMode md)
    {
        return ::access (file, md);
    }

    static MICO_Long getpid ()
    {
        return ::getpid();
    }

    static FILE *popen (const char *cmd, const char *mode)
    {
        return ::popen (cmd, mode);
    }

    static void pclose (FILE *fp)
    {
        ::pclose (fp);
    }

    typedef sigset_t SigState;

    static void block_sigs (SigState &osigs)
    {
        SigState sigs;
        sigemptyset (&sigs);

        sigaddset (&sigs, 17);
        sigprocmask (0, &sigs, &osigs);
    }

    static void restore_sigs (SigState &osigs)
    {
        sigprocmask (2, &osigs, __null);
    }
};
# 32 "../include/mico/util.h" 2

namespace MICO {

  class Logger {
  public:
    enum MessageType {
      Info,
      Warning,
      Error,
      GIOP,
      IIOP,
      Transport,
      All
    };

    static ostream ** _out;
    static Logger * _instance;

  public:
    Logger ();
    ~Logger ();

    static void Log (MessageType, CORBA::Boolean = 1, const char * file = 0);
    static void Log (const char *, CORBA::Boolean = 1, const char * file = 0);
    static CORBA::Boolean IsLogged (MessageType);
    static ostream & Stream (MessageType);
  };

}


class MICOGetOpt {
public:
    typedef map<string, string, less<string> > OptMap;
    typedef vector<pair<string,string> > OptVec;
private:
    OptMap _in_opts;
    OptVec _out_opts;

    CORBA::Boolean parse (const vector<string> &args, vector<int> &erase,
                          CORBA::Boolean ignore = 0);
public:
    MICOGetOpt (const OptMap &opts);
    ~MICOGetOpt ();

    CORBA::Boolean parse (int &argc, char *argv[],
                          CORBA::Boolean ignore = 0);
    CORBA::Boolean parse (const vector<string> &args,
                          CORBA::Boolean ignore = 0);
    CORBA::Boolean parse (const string &filename,
                          CORBA::Boolean ignore = 0);

    const OptVec &opts () const;
};

template<class V>
inline CORBA::Long
mico_vec_compare (V v1, V v2)
{
    int len = v1.size() < v2.size() ? v1.size() : v2.size();
    for (int i = 0; i < len; ++i) {
        if (v1[i] < v2[i])
            return -1;
        if (v2[i] < v1[i])
            return 1;
    }
    return v1.size() - v2.size();
}

static inline CORBA::Long
mico_key_compare (const CORBA::Octet *k1, const CORBA::Octet *k2,
                  CORBA::Long len)
{
    while (--len >= 0) {
        if (*k1 != *k2)
            return (CORBA::Long)*k1 - (CORBA::Long)*k2;
        ++k1;
        ++k2;
    }
    return 0;
}


static inline CORBA::Octet
mico_from_xdigit (CORBA::Octet c)
{
    c = tolower (c);
    ((void) ((isxdigit (c)) ? 0 : (__assert_fail ("isxdigit (c)", "../include/mico/util.h", 119, __PRETTY_FUNCTION__), 0)));
    return isdigit (c) ? c - '0' : c - 'a' + 10;
}

static inline CORBA::Octet
mico_to_xdigit (CORBA::Octet o)
{
    static const char *xdigits = "0123456789abcdef";
    ((void) ((o < 16) ? 0 : (__assert_fail ("o < 16", "../include/mico/util.h", 127, __PRETTY_FUNCTION__), 0)));
    return xdigits[o];
}

extern void mico_ieee2float (CORBA::Octet ieee[4], CORBA::Float &f);
extern void mico_float2ieee (CORBA::Octet ieee[4], CORBA::Float f);
extern void mico_ieee2double (CORBA::Octet ieee[8], CORBA::Double &f);
extern void mico_double2ieee (CORBA::Octet ieee[8], CORBA::Double f);
extern void mico_ieee2ldouble (CORBA::Octet ieee[16], CORBA::LongDouble &f);
extern void mico_ldouble2ieee (CORBA::Octet ieee[16], CORBA::LongDouble f);
extern CORBA::Boolean mico_fnmatch (const char *repoid, const char *patt);

extern string xstrerror (int);
extern string xdec (int);
extern string xdec (long);
extern string xdec (OSMisc::longlong);
extern string xdec (unsigned int);
extern string xdec (unsigned long);
extern string xdec (OSMisc::ulonglong);

extern size_t xwcslen (const wchar_t *);
extern int xwcscmp (const wchar_t *, const wchar_t *);
extern wchar_t *xwcscpy (wchar_t *, const wchar_t *);
extern wchar_t *xwcsncpy (wchar_t *, const wchar_t *, size_t);

extern char * mico_url_encode (const CORBA::Octet *, CORBA::ULong);
extern CORBA::Octet * mico_url_decode (const char *, CORBA::ULong &);

extern CORBA::ULong mico_string_hash (const char *s, CORBA::ULong max);
# 28 "../include/mico/impl.h" 2
# 36 "../include/mico/impl.h"
# 1 "/usr/include/sys/time.h" 1 3 4
# 37 "../include/mico/impl.h" 2
# 1 "/usr/include/sys/socket.h" 1 3 4
# 38 "../include/mico/impl.h" 2



# 1 "/usr/include/sys/select.h" 1 3 4
# 42 "../include/mico/impl.h" 2
# 53 "../include/mico/impl.h"
# 1 "../include/mico/shlib.h" 1
# 27 "../include/mico/shlib.h"
namespace MICO {

class SharedLib {
public:
    virtual ~SharedLib ();

    virtual void *symbol (const char *) = 0;
    virtual const char *error () = 0;
    virtual operator CORBA::Boolean () = 0;

    virtual const char *name () = 0;

    CORBA::Boolean init ();
    void exit ();
};

}
# 54 "../include/mico/impl.h" 2
# 1 "../include/mico/process.h" 1
# 27 "../include/mico/process.h"
namespace MICO {

class Process;

struct ProcessCallback {
    enum Event { Exited };
    virtual void callback (Process *, Event) = 0;
    virtual ~ProcessCallback ();
};

class Process {
public:
    virtual ~Process ();
    virtual CORBA::Boolean run () = 0;
    virtual CORBA::Boolean exited () = 0;
    virtual CORBA::Boolean exit_status () = 0;
    virtual void terminate () = 0;
    virtual void detach () = 0;
    virtual operator CORBA::Boolean () = 0;
};

}
# 55 "../include/mico/impl.h" 2
# 1 "../include/mico/address_impl.h" 1
# 27 "../include/mico/address_impl.h"
namespace MICO {

class LocalAddress : public CORBA::Address {
public:
    LocalAddress ();
    ~LocalAddress ();

    string stringify () const;
    const char *proto () const;
    CORBA::Transport *make_transport () const;
    CORBA::TransportServer *make_transport_server () const;
    CORBA::IORProfile *make_ior_profile (
        CORBA::Octet *, CORBA::ULong, const CORBA::MultiComponent &,
        CORBA::UShort version = 0x0100) const;
    CORBA::Boolean is_local () const;

    CORBA::Address *clone () const;

    CORBA::Long compare (const CORBA::Address &) const;
    CORBA::Boolean operator== (const CORBA::Address &) const;
    CORBA::Boolean operator< (const CORBA::Address &) const;
};

class LocalAddressParser : public CORBA::AddressParser {
public:
    LocalAddressParser ();
    ~LocalAddressParser ();
    CORBA::Address *parse (const char *, const char *) const;
    CORBA::Boolean has_proto (const char *) const;
};


class InetAddress : public CORBA::Address {
public:
    enum Family {
        STREAM,
        DGRAM
    };
private:
    CORBA::UShort _port;
    string _host;
    vector<CORBA::Octet> _ipaddr;
    Family _family;
    static CORBA::Boolean _resolve;

    static string hname;
    static vector<CORBA::Octet> hid;

    CORBA::Boolean resolve_ip () const;
    CORBA::Boolean resolve_host () const;
public:
    InetAddress (struct sockaddr_in &sin, Family = STREAM);
    InetAddress (const char *host = __null, CORBA::UShort port = 0,
                 Family = STREAM);
    InetAddress (const vector<CORBA::Octet> &, CORBA::UShort port = 0,
                 Family = STREAM);
    ~InetAddress ();

    string stringify () const;
    const char *proto () const;
    CORBA::Transport *make_transport () const;
    CORBA::TransportServer *make_transport_server () const;
    CORBA::IORProfile *make_ior_profile (
        CORBA::Octet *, CORBA::ULong, const CORBA::MultiComponent &,
        CORBA::UShort version = 0x0100) const;
    CORBA::Boolean is_local () const;

    CORBA::Address *clone () const;

    CORBA::Long compare (const CORBA::Address &) const;
    CORBA::Boolean operator== (const CORBA::Address &) const;
    CORBA::Boolean operator< (const CORBA::Address &) const;

    CORBA::Boolean valid () const;

    const char *host () const;
    void host (const char *);

    const vector<CORBA::Octet> &ipaddr () const;
    void ipaddr (const vector<CORBA::Octet> &);

    CORBA::UShort port () const;
    void port (CORBA::UShort port);

    void sockaddr (struct sockaddr_in &);
    struct sockaddr_in sockaddr () const;

    void family (Family f);
    Family family () const;

    static string hostname ();
    static vector<CORBA::Octet> hostid();
    static CORBA::Boolean samehosts (const string &h1, const string &h2);

    static CORBA::Boolean resolve ();
    static void resolve (CORBA::Boolean);
};

class InetAddressParser : public CORBA::AddressParser {
public:
    InetAddressParser ();
    ~InetAddressParser ();
    CORBA::Address *parse (const char *, const char *) const;
    CORBA::Boolean has_proto (const char *) const;
};


class UnixAddress : public CORBA::Address {
    string _filename;
public:
    UnixAddress (struct sockaddr_un &una);
    UnixAddress (const char *filename = 0);
    ~UnixAddress ();

    string stringify () const;
    const char *proto () const;
    CORBA::Transport *make_transport () const;
    CORBA::TransportServer *make_transport_server () const;
    CORBA::IORProfile *make_ior_profile (
        CORBA::Octet *, CORBA::ULong, const CORBA::MultiComponent &,
        CORBA::UShort version = 0x0100) const;
    CORBA::Boolean is_local () const;

    CORBA::Address *clone () const;

    CORBA::Long compare (const CORBA::Address &) const;
    CORBA::Boolean operator== (const CORBA::Address &) const;
    CORBA::Boolean operator< (const CORBA::Address &) const;

    const char *filename () const;
    void filename (const char *);

    void sockaddr (struct sockaddr_un &);
    struct sockaddr_un sockaddr () const;
};

class UnixAddressParser : public CORBA::AddressParser {
public:
    UnixAddressParser ();
    ~UnixAddressParser ();
    CORBA::Address *parse (const char *, const char *) const;
    CORBA::Boolean has_proto (const char *) const;
};


}
# 56 "../include/mico/impl.h" 2
# 1 "../include/mico/ior_impl.h" 1
# 27 "../include/mico/ior_impl.h"
namespace MICO {

class LocalProfile : public CORBA::IORProfile {
    string host;
    CORBA::Long pid;
    CORBA::Octet *objkey;
    CORBA::ULong length;
    LocalAddress myaddr;
    ProfileId tagid;
public:
    LocalProfile (CORBA::Octet *objkey, CORBA::ULong length,
                  ProfileId = TAG_LOCAL,
                  const char *host = 0, CORBA::Long pid = -1);
    LocalProfile (const LocalProfile &);
    ~LocalProfile ();
    LocalProfile &operator= (const LocalProfile &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;
};

class LocalProfileDecoder : public CORBA::IORProfileDecoder {
    CORBA::IORProfile::ProfileId tagid;
public:
    LocalProfileDecoder (CORBA::IORProfile::ProfileId

                         = CORBA::IORProfile::TAG_LOCAL

                         );
    ~LocalProfileDecoder ();
    CORBA::IORProfile *decode (CORBA::DataDecoder &,
                               ProfileId, CORBA::ULong) const;
    CORBA::Boolean has_id (ProfileId) const;
};


class IIOPProfile : public CORBA::IORProfile {
    CORBA::Octet *objkey;
    CORBA::ULong length;
    MICO::InetAddress myaddr;
    CORBA::MultiComponent comps;
    ProfileId tagid;
    CORBA::UShort version;
public:
    IIOPProfile (CORBA::Octet *objkey, CORBA::ULong length,
                 const InetAddress &,
                 const CORBA::MultiComponent & = CORBA::MultiComponent(),
                 CORBA::UShort version = 0x0100,
                 ProfileId = TAG_INTERNET_IOP);
    IIOPProfile (const IIOPProfile &);
    ~IIOPProfile ();
    IIOPProfile &operator= (const IIOPProfile &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;

    CORBA::UShort iiop_version () const
    { return version; }

    CORBA::MultiComponent *components()
    { return &comps; }
};

class IIOPProfileDecoder : public CORBA::IORProfileDecoder {
    CORBA::IORProfile::ProfileId tagid;
    MICO::InetAddress::Family family;
public:
    IIOPProfileDecoder (CORBA::IORProfile::ProfileId

                        = CORBA::IORProfile::TAG_INTERNET_IOP

                        , MICO::InetAddress::Family

                        = MICO::InetAddress::STREAM

                );
    ~IIOPProfileDecoder ();
    CORBA::IORProfile *decode (CORBA::DataDecoder &, ProfileId,
                               CORBA::ULong) const;
    CORBA::Boolean has_id (ProfileId) const;
};



class UIOPProfile : public CORBA::IORProfile {
    string host;
    CORBA::Octet *objkey;
    CORBA::ULong length;
    UnixAddress myaddr;
    ProfileId tagid;
    CORBA::MultiComponent comps;
    CORBA::UShort version;
public:
    UIOPProfile (CORBA::Octet *objkey, CORBA::ULong length,
                 const UnixAddress &,
                 const CORBA::MultiComponent &,
                 CORBA::UShort version = 0x0100,
                 ProfileId = TAG_UNIX_IOP,
                 const char *host = 0);
    UIOPProfile (const UIOPProfile &);
    ~UIOPProfile ();
    UIOPProfile &operator= (const UIOPProfile &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;
};

class UIOPProfileDecoder : public CORBA::IORProfileDecoder {
    CORBA::IORProfile::ProfileId tagid;
public:
    UIOPProfileDecoder (CORBA::IORProfile::ProfileId
                        = CORBA::IORProfile::TAG_UNIX_IOP);
    ~UIOPProfileDecoder ();
    CORBA::IORProfile *decode (CORBA::DataDecoder &, ProfileId,
                               CORBA::ULong) const;
    CORBA::Boolean has_id (ProfileId) const;
};



class MultiCompProfile : public CORBA::IORProfile {
    CORBA::MultiComponent _mc;
    ProfileId _tagid;
public:
    MultiCompProfile (const CORBA::MultiComponent &mc,
                      ProfileId tagid = TAG_MULTIPLE_COMPONENTS);
    MultiCompProfile (const MultiCompProfile &);
    ~MultiCompProfile ();
    MultiCompProfile &operator= (const MultiCompProfile &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;

    CORBA::MultiComponent *components();
};

class MultiCompProfileDecoder : public CORBA::IORProfileDecoder {
    CORBA::IORProfile::ProfileId _tagid;
public:
    MultiCompProfileDecoder (CORBA::IORProfile::ProfileId

                             = CORBA::IORProfile::TAG_MULTIPLE_COMPONENTS

                             );
    ~MultiCompProfileDecoder ();
    CORBA::IORProfile *decode (CORBA::DataDecoder &,
                               ProfileId, CORBA::ULong) const;
    CORBA::Boolean has_id (ProfileId) const;
};


class UnknownProfile : public CORBA::IORProfile {
    ProfileId tagid;
    vector<CORBA::Octet> tagdata;
public:
    UnknownProfile (ProfileId id);
    UnknownProfile (const UnknownProfile &);
    ~UnknownProfile ();
    UnknownProfile &operator= (const UnknownProfile &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;

    static UnknownProfile *decode (CORBA::DataDecoder &,
                                   ProfileId id, CORBA::ULong len);
};


class UnknownComponent : public CORBA::Component {
    ComponentId tagid;
    vector<CORBA::Octet> tagdata;
public:
    UnknownComponent (ComponentId id, CORBA::Octet * = 0,
                      CORBA::ULong len = 0);
    UnknownComponent (const UnknownComponent &);
    ~UnknownComponent ();
    UnknownComponent &operator= (const UnknownComponent &);

    void encode (CORBA::DataEncoder &) const;
    ComponentId id () const;
    void print (ostream &) const;

    CORBA::Component *clone () const;
    CORBA::Long compare (const CORBA::Component &) const;
    CORBA::Boolean operator== (const CORBA::Component &) const;
    CORBA::Boolean operator< (const CORBA::Component &) const;

    static UnknownComponent *decode (CORBA::DataDecoder &,
                                     ComponentId id, CORBA::ULong len);
};

}
# 57 "../include/mico/impl.h" 2
# 1 "../include/mico/transport_impl.h" 1
# 27 "../include/mico/transport_impl.h"
namespace MICO {

class SelectDispatcher : public CORBA::Dispatcher {
    typedef fd_set FDSet;

    struct FileEvent {
        Event event;
        CORBA::Long fd;
        CORBA::DispatcherCallback *cb;
        CORBA::Boolean deleted;

        FileEvent () {}
        FileEvent (Event _ev, CORBA::Long _fd, CORBA::DispatcherCallback *_cb)
            : event(_ev), fd(_fd), cb(_cb), deleted(0)
        {}
    };
    struct TimerEvent {
        Event event;
        CORBA::Long delta;
        CORBA::DispatcherCallback *cb;

        TimerEvent () {}
        TimerEvent (Event _ev, CORBA::Long _delta,
                    CORBA::DispatcherCallback *_cb)
            : event(_ev), delta(_delta), cb(_cb)
        {}
    };

    list<FileEvent> fevents;
    list<TimerEvent> tevents;

    CORBA::Long last_update;
    CORBA::Boolean init;
    CORBA::Long locked;
    CORBA::Boolean modified;
    FDSet curr_wset, curr_rset, curr_xset;
    CORBA::Long fd_max;

    void lock ();
    void unlock ();
    CORBA::Boolean islocked () const;

    CORBA::Long gettime () const;
    void update_tevents ();
    void handle_tevents ();
    void handle_fevents (FDSet &rset, FDSet &wset, FDSet &xset);
    void update_fevents ();
    void sleeptime (OSMisc::TimeVal &);
public:
    SelectDispatcher ();
    virtual ~SelectDispatcher ();
    virtual void rd_event (CORBA::DispatcherCallback *, CORBA::Long fd);
    virtual void wr_event (CORBA::DispatcherCallback *, CORBA::Long fd);
    virtual void ex_event (CORBA::DispatcherCallback *, CORBA::Long fd);
    virtual void tm_event (CORBA::DispatcherCallback *, CORBA::ULong tmout);
    virtual void remove (CORBA::DispatcherCallback *, Event);
    virtual void move (CORBA::Dispatcher *);
    virtual void run (CORBA::Boolean infinite = 1);
    virtual CORBA::Boolean idle () const;
};


class TCPTransport : public CORBA::Transport,
                     public CORBA::DispatcherCallback {
    CORBA::Dispatcher *rdisp, *wdisp;
    CORBA::TransportCallback *rcb, *wcb;
    CORBA::Long fd;
    CORBA::Boolean ateof;
    string err;
    InetAddress local_addr, peer_addr;
    CORBA::Boolean is_blocking;
    CORBA::Boolean is_buffering;
public:
    TCPTransport (CORBA::Long fd = -1);
    ~TCPTransport ();

    void rselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void wselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    CORBA::Boolean connect (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();
    void buffering (CORBA::Boolean dobuffering = 1);
    CORBA::Boolean isbuffering ();
    CORBA::Boolean isreadable ();

    CORBA::Long read (void *, CORBA::Long len);
    CORBA::Long write (const void *, CORBA::Long len);

    const CORBA::Address *addr ();
    const CORBA::Address *peer ();

    CORBA::Boolean eof () const;
    CORBA::Boolean bad () const;
    string errormsg () const;
};


class TCPTransportServer : public CORBA::TransportServer,
                           public CORBA::DispatcherCallback {
    CORBA::Dispatcher *adisp;
    CORBA::TransportServerCallback *acb;
    CORBA::Long fd;
    string err;
    InetAddress local_addr;
    CORBA::Boolean listening;
    void listen ();
    CORBA::Boolean is_blocking;
public:
    TCPTransportServer ();
    ~TCPTransportServer ();

    void aselect (CORBA::Dispatcher *,
                  CORBA::TransportServerCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();

    CORBA::Transport *accept ();
    const CORBA::Address *addr ();

    CORBA::Boolean bad () const;
    string errormsg () const;
};


class UDPTransport : public CORBA::Transport,
                     public CORBA::DispatcherCallback {
    CORBA::Dispatcher *rdisp, *wdisp;
    CORBA::TransportCallback *rcb, *wcb;
    CORBA::Long fd;
    string err;
    InetAddress local_addr, peer_addr;
    CORBA::Boolean is_blocking;
    CORBA::Buffer dgram;
    CORBA::Boolean is_established;
    CORBA::Boolean is_connected;
    CORBA::Boolean is_bound;
    struct sockaddr_in *peer_sin, *addr_sin;

    CORBA::Long collect_replies (CORBA::Long tmout);
public:
    UDPTransport (CORBA::Long fd = -1);
    ~UDPTransport ();

    void rselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void wselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    CORBA::Boolean connect (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();
    CORBA::Boolean isreadable ();

    CORBA::Long read (void *, CORBA::Long len);
    CORBA::Long write (const void *, CORBA::Long len);

    const CORBA::Address *addr ();
    const CORBA::Address *peer ();

    CORBA::Boolean eof () const;
    CORBA::Boolean bad () const;
    string errormsg () const;

    CORBA::Boolean bind_server (const CORBA::Address *);
    CORBA::Boolean connect_server (const CORBA::Address *);
    CORBA::Long read_dgram (CORBA::Buffer &buf);
};


class UDPTransportServer : public CORBA::TransportServer,
                           public CORBA::DispatcherCallback {
    CORBA::Dispatcher *adisp;
    CORBA::TransportServerCallback *acb;
    CORBA::Long fd;
    string err;
    InetAddress local_addr;
    CORBA::Boolean is_blocking;
    CORBA::Boolean is_bound;
    struct sockaddr_in *addr_sin;
public:
    UDPTransportServer ();
    ~UDPTransportServer ();

    void aselect (CORBA::Dispatcher *,
                  CORBA::TransportServerCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();

    CORBA::Transport *accept ();
    const CORBA::Address *addr ();

    CORBA::Boolean bad () const;
    string errormsg () const;
};



class UnixTransport : public CORBA::Transport,
                      public CORBA::DispatcherCallback {
    CORBA::Dispatcher *rdisp, *wdisp;
    CORBA::TransportCallback *rcb, *wcb;
    CORBA::Long fd;
    CORBA::Boolean ateof;
    string err;
    UnixAddress local_addr, peer_addr;
    CORBA::Boolean is_blocking;
public:
    UnixTransport (CORBA::Long fd = -1);
    ~UnixTransport ();

    void rselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void wselect (CORBA::Dispatcher *, CORBA::TransportCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    CORBA::Boolean connect (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();
    CORBA::Boolean isreadable ();

    CORBA::Long read (void *, CORBA::Long len);
    CORBA::Long write (const void *, CORBA::Long len);

    const CORBA::Address *addr ();
    const CORBA::Address *peer ();

    CORBA::Boolean eof () const;
    CORBA::Boolean bad () const;
    string errormsg () const;
};


class UnixTransportServer : public CORBA::TransportServer,
                            public CORBA::DispatcherCallback {
    CORBA::Dispatcher *adisp;
    CORBA::TransportServerCallback *acb;
    CORBA::Long fd;
    string err;
    UnixAddress local_addr;
    CORBA::Boolean listening;
    void listen ();
    CORBA::Boolean is_blocking;
public:
    UnixTransportServer ();
    ~UnixTransportServer ();

    void aselect (CORBA::Dispatcher *,
                  CORBA::TransportServerCallback *);
    void callback (CORBA::Dispatcher *, CORBA::Dispatcher::Event);

    CORBA::Boolean bind (const CORBA::Address *);
    void close ();
    void block (CORBA::Boolean doblock = 1);
    CORBA::Boolean isblocking ();

    CORBA::Transport *accept ();
    const CORBA::Address *addr ();

    CORBA::Boolean bad () const;
    string errormsg () const;
};


}
# 58 "../include/mico/impl.h" 2
# 1 "../include/mico/shlib_impl.h" 1
# 27 "../include/mico/shlib_impl.h"
namespace MICO {

class UnixSharedLib : public MICO::SharedLib {
    void *_handle;
    string _error;
    string _name;
public:
    UnixSharedLib (const char *name);
    virtual ~UnixSharedLib ();

    virtual void *symbol (const char *);
    virtual const char *error ();
    virtual operator CORBA::Boolean ();

    virtual const char *name ();
};

}
# 59 "../include/mico/impl.h" 2
# 1 "../include/mico/process_impl.h" 1
# 30 "../include/mico/process_impl.h"
namespace MICO {

class UnixProcess : public MICO::Process, public CORBA::DispatcherCallback {

    CORBA::Long _exit_status;
    CORBA::Boolean _detached;
    MICO::ProcessCallback *_cb;
    string _args;
# 59 "../include/mico/process_impl.h"
    CORBA::Long _pid;

    typedef list<UnixProcess *> ListProcess;
    static ListProcess _procs;

    static void signal_handler (int sig);
public:




    UnixProcess (const char *cmd, MICO::ProcessCallback * = 0);
    virtual ~UnixProcess ();

    virtual CORBA::Boolean run ();
    virtual CORBA::Boolean exited ();
    virtual CORBA::Boolean exit_status ();
    virtual void terminate ();
    virtual void detach ();
    virtual operator CORBA::Boolean ();

    virtual void callback (CORBA::Dispatcher *,
                           CORBA::DispatcherCallback::Event);
};

}
# 60 "../include/mico/impl.h" 2
# 1 "../include/mico/codec_impl.h" 1
# 27 "../include/mico/codec_impl.h"
namespace MICO {

class CDREncoder : public CORBA::DataEncoder {
    CORBA::ByteOrder data_bo, mach_bo;
public:
    CDREncoder ();






    CDREncoder (CORBA::Buffer *, CORBA::Boolean do_free = 1,
                CORBA::ByteOrder = CORBA::DefaultEndian,
                CORBA::CodeSetCoder *c = 0, CORBA::Boolean dofree_c = 1,
                ValueState *vs = 0, CORBA::Boolean dofree_vs = 1);

    ~CDREncoder ();

    CORBA::DataEncoder *clone () const;
    CORBA::DataEncoder *clone (CORBA::Buffer *,
                               CORBA::Boolean dofree_b = 1,
                               CORBA::CodeSetCoder *c = 0,
                               CORBA::Boolean dofree_c = 1,
                               ValueState *vs = 0,
                               CORBA::Boolean dofree_vs = 1) const;
    CORBA::DataDecoder *decoder () const;
    CORBA::DataDecoder *decoder (CORBA::Buffer *,
                                 CORBA::Boolean dofree_b = 1,
                                 CORBA::CodeSetCoder *c = 0,
                                 CORBA::Boolean dofree_c = 1) const;
    const char *type () const;

    void put_short (CORBA::Short);
    void put_ushort (CORBA::UShort);
    void put_long (CORBA::Long);
    void put_longlong (CORBA::LongLong);
    void put_ulong (CORBA::ULong);
    void put_ulonglong (CORBA::ULongLong);
    void put_float (CORBA::Float);
    void put_double (CORBA::Double);
    void put_longdouble (CORBA::LongDouble);
    void put_char (CORBA::Char);
    void put_char_raw (CORBA::Char);
    void put_wchar (CORBA::WChar);
    void put_octet (CORBA::Octet);
    void put_boolean (CORBA::Boolean);
    void put_string (const char *);
    void put_string_raw (const char *);
    void put_wstring (const wchar_t *);
    void put_fixed (const FixedBase::FixedValue &value,
                    CORBA::UShort digits,
                    CORBA::Short scale);


    void put_shorts (const CORBA::Short *, CORBA::ULong);
    void put_ushorts (const CORBA::UShort *, CORBA::ULong);
    void put_longs (const CORBA::Long *, CORBA::ULong);
    void put_longlongs (const CORBA::LongLong *, CORBA::ULong);
    void put_ulongs (const CORBA::ULong *, CORBA::ULong);
    void put_ulonglongs (const CORBA::ULongLong *, CORBA::ULong);
    void put_floats (const CORBA::Float *, CORBA::ULong);
    void put_doubles (const CORBA::Double *, CORBA::ULong);
    void put_longdoubles (const CORBA::LongDouble *, CORBA::ULong);
    void put_chars (const CORBA::Char *, CORBA::ULong);
    void put_chars_raw (const CORBA::Char *, CORBA::ULong);
    void put_wchars (const CORBA::WChar *, CORBA::ULong);
    void put_booleans (const CORBA::Boolean *, CORBA::ULong);

    CORBA::ULong max_alignment () const;

    CORBA::ByteOrder byteorder () const;
    void byteorder (CORBA::ByteOrder);
};


class CDRDecoder : public CORBA::DataDecoder {
    CORBA::ByteOrder data_bo, mach_bo;
public:
    CDRDecoder ();






    CDRDecoder (CORBA::Buffer *b, CORBA::Boolean do_free = 1,
                CORBA::ByteOrder = CORBA::DefaultEndian,
                CORBA::CodeSetCoder *c = 0, CORBA::Boolean dofree_c = 1,
                ValueState *vs = 0, CORBA::Boolean dofree_vs = 1);

    ~CDRDecoder ();

    CORBA::DataDecoder *clone () const;
    CORBA::DataDecoder *clone (CORBA::Buffer *b,
                               CORBA::Boolean dofree_b = 1,
                               CORBA::CodeSetCoder *c = 0,
                               CORBA::Boolean dofree_c = 1,
                               ValueState *vs = 0,
                               CORBA::Boolean dofree_vs = 1) const;
    CORBA::DataEncoder *encoder () const;
    CORBA::DataEncoder *encoder (CORBA::Buffer *b,
                                 CORBA::Boolean dofree_b = 1,
                                 CORBA::CodeSetCoder *c = 0,
                                 CORBA::Boolean dofree_c = 1) const;
    const char *type () const;

    CORBA::Boolean get_short (CORBA::Short &);
    CORBA::Boolean get_ushort (CORBA::UShort &);
    CORBA::Boolean get_long (CORBA::Long &);
    CORBA::Boolean get_longlong (CORBA::LongLong &);
    CORBA::Boolean get_ulong (CORBA::ULong &);
    CORBA::Boolean get_ulonglong (CORBA::ULongLong &);
    CORBA::Boolean get_float (CORBA::Float &);
    CORBA::Boolean get_double (CORBA::Double &);
    CORBA::Boolean get_longdouble (CORBA::LongDouble &);
    CORBA::Boolean get_char (CORBA::Char &);
    CORBA::Boolean get_char_raw (CORBA::Char &);
    CORBA::Boolean get_wchar (CORBA::WChar &);
    CORBA::Boolean get_octet (CORBA::Octet &);
    CORBA::Boolean get_boolean (CORBA::Boolean &);
    CORBA::Boolean get_string (CORBA::String_out);
    CORBA::Boolean get_string_raw (CORBA::String_out);
    CORBA::Boolean get_wstring (CORBA::WString_out);
    CORBA::Boolean get_fixed (FixedBase::FixedValue &val,
                              CORBA::UShort digits,
                              CORBA::Short scale);

    CORBA::Boolean get_shorts (CORBA::Short *, CORBA::ULong);
    CORBA::Boolean get_ushorts (CORBA::UShort *, CORBA::ULong);
    CORBA::Boolean get_longs (CORBA::Long *, CORBA::ULong);
    CORBA::Boolean get_longlongs (CORBA::LongLong *, CORBA::ULong);
    CORBA::Boolean get_ulongs (CORBA::ULong *, CORBA::ULong);
    CORBA::Boolean get_ulonglongs (CORBA::ULongLong *, CORBA::ULong);
    CORBA::Boolean get_floats (CORBA::Float *, CORBA::ULong);
    CORBA::Boolean get_doubles (CORBA::Double *, CORBA::ULong);
    CORBA::Boolean get_longdoubles (CORBA::LongDouble *, CORBA::ULong);
    CORBA::Boolean get_chars (CORBA::Char *, CORBA::ULong);
    CORBA::Boolean get_chars_raw (CORBA::Char *, CORBA::ULong);
    CORBA::Boolean get_wchars (CORBA::WChar *, CORBA::ULong);
    CORBA::Boolean get_booleans (CORBA::Boolean *, CORBA::ULong);

    CORBA::ULong max_alignment () const;

    CORBA::ByteOrder byteorder () const;
    void byteorder (CORBA::ByteOrder);
};

}
# 61 "../include/mico/impl.h" 2
# 1 "../include/mico/codeset_impl.h" 1
# 27 "../include/mico/codeset_impl.h"
namespace MICO {





class CodesetComponent : public CORBA::Component {
public:
    typedef CORBA::ULong CodeSetId;
private:
    CodeSetId _native_cs;
    CodeSetId _native_wcs;
    vector<CodeSetId> _conv_cs;
    vector<CodeSetId> _conv_wcs;
    CodeSetId _selected_cs;
    CodeSetId _selected_wcs;
public:
    CodesetComponent ();
    CodesetComponent (CodeSetId native_cs, CodeSetId native_wcs,
                      const vector<CodeSetId> &conv_cs,
                      const vector<CodeSetId> &conv_wcs);
    CodesetComponent (const CodesetComponent &csc);
    ~CodesetComponent ();

    void encode (CORBA::DataEncoder &) const;
    ComponentId id () const;
    void print (ostream &) const;

    CORBA::Component *clone () const;
    CORBA::Long compare (const CORBA::Component &) const;
    CORBA::Boolean operator== (const CORBA::Component &) const;
    CORBA::Boolean operator< (const CORBA::Component &) const;

    CodeSetId selected_cs ();
    CodeSetId selected_wcs ();
};


class CodesetComponentDecoder : public CORBA::ComponentDecoder {
public:
    CodesetComponentDecoder ();
    ~CodesetComponentDecoder ();

    CORBA::Component *decode (CORBA::DataDecoder &,
                              ComponentId, CORBA::ULong) const;
    CORBA::Boolean has_id (ComponentId) const;
};





class CodesetConv {
protected:
  CORBA::Codeset *_from;
  CORBA::Codeset *_to;

  CodesetConv ();
  CodesetConv (const CodesetConv &);
  CodesetConv (CORBA::Codeset *, CORBA::Codeset *);
public:
  virtual ~CodesetConv ();

  static CodesetConv *create (CORBA::Codeset *from,
                              CORBA::Codeset *to);
  static CORBA::Boolean can_convert (CORBA::Codeset::CodesetId from,
                                     CORBA::Codeset::CodesetId to);

  CORBA::Codeset *from ()
    { return _from; }

  CORBA::Codeset *to ()
    { return _to; }

  virtual CodesetConv *clone () const;




  virtual CORBA::Long encode (const CORBA::Char *from, CORBA::ULong len,
                              CORBA::Buffer &to,
                              CORBA::Boolean terminate = 1);
  virtual CORBA::Long encode (const CORBA::WChar *from, CORBA::ULong len,
                              CORBA::Buffer &to,
                              CORBA::Boolean terminate = 1);
  virtual CORBA::Long decode (CORBA::Buffer &from, CORBA::ULong len,
                              CORBA::WChar *to,
                              CORBA::Boolean terminate = 1);
  virtual CORBA::Long decode (CORBA::Buffer &from, CORBA::ULong len,
                              CORBA::Char *to,
                              CORBA::Boolean terminate = 1);
};

class UniCodesetConv : public CodesetConv {
protected:
  UniCodesetConv ();
  UniCodesetConv (const UniCodesetConv &);
  UniCodesetConv (CORBA::Codeset *, CORBA::Codeset *);

  static CORBA::Boolean supported_csid (CORBA::Codeset::CodesetId);

  CORBA::Long convert (const char *from, CORBA::ULong len,
                       char *to);
public:
  ~UniCodesetConv ();

  static CodesetConv *create (CORBA::Codeset *from,
                              CORBA::Codeset *to);
  static CORBA::Boolean can_convert (CORBA::Codeset::CodesetId from,
                                     CORBA::Codeset::CodesetId to);

  CodesetConv *clone () const;




  CORBA::Long encode (const CORBA::Char *from, CORBA::ULong len,
                      CORBA::Buffer &to,
                      CORBA::Boolean terminate = 1);
  CORBA::Long encode (const CORBA::WChar *from, CORBA::ULong len,
                      CORBA::Buffer &to,
                      CORBA::Boolean terminate = 1);
  CORBA::Long decode (CORBA::Buffer &from, CORBA::ULong len,
                      CORBA::WChar *to,
                      CORBA::Boolean terminate = 1);
  CORBA::Long decode (CORBA::Buffer &from, CORBA::ULong len,
                      CORBA::Char *to,
                      CORBA::Boolean terminate = 1);
};







class GIOP_1_0_CodeSetCoder : public CORBA::CodeSetCoder
{
private:
  MICO::CodesetConv * _conv;
  CORBA::Boolean _isok;

public:
  GIOP_1_0_CodeSetCoder ();
  ~GIOP_1_0_CodeSetCoder ();

  CORBA::CodeSetCoder * clone ();
  CORBA::Boolean isok ();

  CORBA::Boolean get_char (CORBA::DataDecoder &, CORBA::Char &);
  CORBA::Boolean get_chars (CORBA::DataDecoder &, CORBA::Char *, CORBA::ULong);
  CORBA::Boolean get_string (CORBA::DataDecoder &, CORBA::String_out,
                             CORBA::ULong);

  CORBA::Boolean get_wchar (CORBA::DataDecoder &, CORBA::WChar &);
  CORBA::Boolean get_wchars (CORBA::DataDecoder &, CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean get_wstring (CORBA::DataDecoder &, CORBA::WString_out,
                              CORBA::ULong);

  CORBA::Boolean put_char (CORBA::DataEncoder &, CORBA::Char);
  CORBA::Boolean put_chars (CORBA::DataEncoder &, const CORBA::Char *, CORBA::ULong);
  CORBA::Boolean put_string (CORBA::DataEncoder &, const char *, CORBA::ULong);

  CORBA::Boolean put_wchar (CORBA::DataEncoder &, CORBA::WChar);
  CORBA::Boolean put_wchars (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean put_wstring (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
};
# 204 "../include/mico/codeset_impl.h"
class GIOP_1_1_CodeSetCoder : public CORBA::CodeSetCoder
{
protected:
  CORBA::Codeset::CodesetId _tcsc;
private:
  MICO::CodesetConv * _conv_n2t;
  MICO::CodesetConv * _conv_t2n;
  CORBA::ULong _max_codepoints;
  CORBA::ULong _codepoint_size;
  CORBA::Boolean _isok;

public:
  GIOP_1_1_CodeSetCoder (CORBA::Codeset::CodesetId tcsc);
  ~GIOP_1_1_CodeSetCoder ();

  CORBA::CodeSetCoder * clone ();
  CORBA::Boolean isok ();

  CORBA::Boolean get_char (CORBA::DataDecoder &, CORBA::Char &);
  CORBA::Boolean get_chars (CORBA::DataDecoder &, CORBA::Char *, CORBA::ULong);
  CORBA::Boolean get_string (CORBA::DataDecoder &, CORBA::String_out,
                             CORBA::ULong);

  CORBA::Boolean get_wchar (CORBA::DataDecoder &, CORBA::WChar &);
  CORBA::Boolean get_wchars (CORBA::DataDecoder &, CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean get_wstring (CORBA::DataDecoder &, CORBA::WString_out,
                              CORBA::ULong);

  CORBA::Boolean put_char (CORBA::DataEncoder &, CORBA::Char);
  CORBA::Boolean put_chars (CORBA::DataEncoder &, const CORBA::Char *, CORBA::ULong);
  CORBA::Boolean put_string (CORBA::DataEncoder &, const char *, CORBA::ULong);

  CORBA::Boolean put_wchar (CORBA::DataEncoder &, CORBA::WChar);
  CORBA::Boolean put_wchars (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean put_wstring (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
};
# 254 "../include/mico/codeset_impl.h"
class GIOP_1_2_CodeSetCoder : public GIOP_1_1_CodeSetCoder
{
private:
  CORBA::Codeset::CodesetId _tcsw;
  MICO::CodesetConv * _w_conv_n2t;
  MICO::CodesetConv * _w_conv_t2n;
  CORBA::ULong _w_max_codepoints;
  CORBA::ULong _w_codepoint_size;
  CORBA::ULong _w_native_maxcp;
  CORBA::Boolean _w_isok;

public:
  GIOP_1_2_CodeSetCoder (CORBA::Codeset::CodesetId tcsc,
                         CORBA::Codeset::CodesetId tcsw);
  ~GIOP_1_2_CodeSetCoder ();

  CORBA::CodeSetCoder * clone ();
  CORBA::Boolean isok ();

  CORBA::Boolean get_wchar (CORBA::DataDecoder &, CORBA::WChar &);
  CORBA::Boolean get_wchars (CORBA::DataDecoder &, CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean get_wstring (CORBA::DataDecoder &, CORBA::WString_out,
                              CORBA::ULong);

  CORBA::Boolean put_wchar (CORBA::DataEncoder &, CORBA::WChar);
  CORBA::Boolean put_wchars (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
  CORBA::Boolean put_wstring (CORBA::DataEncoder &, const CORBA::WChar *, CORBA::ULong);
};

}
# 62 "../include/mico/impl.h" 2
# 1 "../include/mico/orb_impl.h" 1
# 27 "../include/mico/orb_impl.h"
namespace MICO {

class LocalRequest : public CORBA::ORBRequest {
    CORBA::Request_ptr _req;
    CORBA::Boolean _have_except;
    CORBA::Boolean _have_result;
public:
    LocalRequest ();
    LocalRequest (CORBA::Request_ptr);
    ~LocalRequest ();

    const char *op_name();

    CORBA::Boolean get_in_args (CORBA::NVList_ptr iparams,
                                CORBA::Context_ptr &ctx);
    CORBA::Boolean get_in_args (StaticAnyList *iparams,
                                CORBA::Context_ptr &ctx);
    CORBA::Boolean get_in_args (CORBA::DataEncoder *);

    CORBA::Boolean get_out_args (CORBA::Any *res,
                                 CORBA::NVList_ptr oparams,
                                 CORBA::Exception *&ex);
    CORBA::Boolean get_out_args (CORBA::StaticAny *res, StaticAnyList *oparams,
                                 CORBA::Exception *&ex);
    CORBA::Boolean get_out_args (CORBA::DataEncoder *,
                                 CORBA::Boolean &is_except);

    CORBA::Boolean set_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams);
    CORBA::Boolean set_out_args (CORBA::StaticAny *res,
                                 StaticAnyList *oparams);
    void set_out_args (CORBA::Exception *ex);
    CORBA::Boolean set_out_args (CORBA::DataDecoder *,
                                 CORBA::Boolean is_except);

    CORBA::Boolean copy_out_args (CORBA::ORBRequest *);
    CORBA::Boolean copy_in_args (CORBA::ORBRequest *);

    const char *type ();

    CORBA::Request_ptr request ();

    static LocalRequest* _nil ()
    {
        return 0;
    }
    static LocalRequest* _duplicate (LocalRequest *o)
    {
        if (o)
            o->_ref();
        return o;
    }
};


class ReqQueueRec {
public:
    typedef CORBA::ULong MsgId;
private:
    CORBA::RequestType _type;
    string _repoid;
    CORBA::ORBRequest *_request;
    CORBA::Object_ptr _obj;
    CORBA::Principal_ptr _pr;
    MsgId _id;
    CORBA::Boolean _response_exp;
    CORBA::ORB::ObjectTag _tag;
public:
    ReqQueueRec (MsgId id, CORBA::ORBRequest *, CORBA::Object_ptr,
                 CORBA::Principal_ptr, CORBA::Boolean resp);
    ReqQueueRec (MsgId id, const char *repoid,
                 const CORBA::ORB::ObjectTag &);
    ReqQueueRec (MsgId id, CORBA::Object_ptr obj);
    ~ReqQueueRec ();

    void exec (CORBA::ObjectAdapter *, CORBA::ORB_ptr);
    void fail (CORBA::ObjectAdapter *, CORBA::ORB_ptr);

    CORBA::Object_ptr target ();
    MsgId id () const
    { return _id; }
};

class RequestQueue : public CORBA::DispatcherCallback {
public:
    typedef CORBA::ULong MsgId;
private:
    typedef list<ReqQueueRec *> InvokeList;
    MsgId _current_id;
    InvokeList _invokes;
    CORBA::ObjectAdapter *_oa;
    CORBA::ORB_ptr _orb;
public:
    RequestQueue (CORBA::ObjectAdapter *, CORBA::ORB_ptr);
    ~RequestQueue ();

    void add (ReqQueueRec *);
    void exec_now ();
    void exec_later ();
    void exec_stop ();
    void fail ();
    void clear ();

    CORBA::Boolean iscurrent (MsgId id) const
    { return _current_id && id == _current_id; }

    CORBA::ULong size () const
    { return _invokes.size(); }


    virtual void callback (CORBA::Dispatcher *,
                           CORBA::DispatcherCallback::Event);
};

}
# 63 "../include/mico/impl.h" 2
# 1 "../include/mico/boa_impl.h" 1
# 27 "../include/mico/boa_impl.h"
namespace MICO {

class BOAServImpl;

enum BOAState {
    BOAActive,
    BOAShutdown,
    BOAInactive
};

class ObjectRecord {
    CORBA::BOA::ReferenceData _id;
    CORBA::ImplementationDef * _impl;
    CORBA::InterfaceDef * _iface;
    CORBA::Object_ptr _local_obj;
    CORBA::Object_ptr _remote_obj;
    CORBA::ImplementationBase *_skel;
    CORBA::Boolean _save;

    BOAState _state;
    CORBA::Boolean _persistent;
public:

    ObjectRecord (CORBA::Object_ptr local, const CORBA::BOA::ReferenceData &,
                  CORBA::InterfaceDef *, CORBA::ImplementationDef *,
                  CORBA::ImplementationBase * = __null);
    ObjectRecord (CORBA::Object_ptr local, CORBA::Object_ptr remote,
                  const CORBA::BOA::ReferenceData &,
                  CORBA::InterfaceDef *, CORBA::ImplementationDef *,
                  CORBA::ImplementationBase * = __null);
    ~ObjectRecord ();

    CORBA::BOA::ReferenceData *id ();

    CORBA::ImplementationDef *impl ();
    void impl (CORBA::ImplementationDef *);

    CORBA::InterfaceDef *iface ();
    void iface (CORBA::InterfaceDef *);

    CORBA::Object_ptr local_obj ();
    CORBA::Object_ptr remote_obj ();

    CORBA::ImplementationBase *skel ();
    void skel (CORBA::ImplementationBase *);

    void save (CORBA::Boolean);
    CORBA::Boolean save () const;

    void persistent (CORBA::Boolean);
    CORBA::Boolean persistent () const;

    void state (BOAState);
    BOAState state () const;
};

struct BOAObjKey {
    const CORBA::Octet *key;
    CORBA::Long len;

    BOAObjKey (CORBA::Object_ptr o)
    {
        key = o->_ior()->profile()->objectkey (len);
    }
    BOAObjKey ()
    {
    }
};

class BOAImpl : public CORBA::BOA, public CORBA::ObjectAdapter {
    struct objcomp : binary_function<const BOAObjKey &, const BOAObjKey &, bool> {
        bool operator() (const BOAObjKey &k1, const BOAObjKey &k2) const
        {
            if (k1.len != k2.len)
                return k1.len < k2.len;
            return mico_key_compare (k1.key, k2.key, k1.len) < 0;
        }
    };
    typedef map<BOAObjKey, ObjectRecord *, objcomp> MapObjRec;
    typedef list<MICO::SharedLib *> ListShlib;

    MapObjRec _lobjs, _robjs;
    ListShlib _shlibs;
    CORBA::ORB_ptr _orb;
    CORBA::ULong _theid;
    CORBA::OAMediator *_oamed;
    CORBA::OAServer *_oasrv;
    CORBA::OAMediator::ServerId _oasrv_id;
    CORBA::Object_ptr _active_obj;
    CORBA::ImplementationDef::ActivationMode _amode;
    string _impl_name;
    CORBA::Boolean _restoring;
    BOAState _state;
    CORBA::Environment_ptr _curr_environ;
    MICO::RequestQueue _queue;
    CORBA::Long _queue_count;
    CORBA::Octet _id_template[11];

    void queue ();
    void unqueue ();
    CORBA::Boolean must_queue (MsgId);
    CORBA::ImplementationDef *find_impl ();
    CORBA::Object_ptr find_obj ();
    void add_record (ObjectRecord *);
    ObjectRecord *get_record (CORBA::Object_ptr);
    void del_record (CORBA::Object_ptr);
    void del_all_records ();
    void unique_id (vector<CORBA::Octet> &id);
    CORBA::Boolean is_builtin_invoke (const char *opname);
    void builtin_invoke (CORBA::Object_ptr,
                         CORBA::ServerRequest_ptr,
                         CORBA::Principal_ptr);
    CORBA::Boolean activate (const char *repoid);
    void shutdown_obj (CORBA::Object_ptr);
    void shutdown_impl ();
    void restore_internal (CORBA::Object_ptr);

    CORBA::Boolean dobind (MsgId, const char *repoid,
                           const CORBA::ORB::ObjectTag &,
                           CORBA::Address *addr);

    CORBA::Boolean is_active_object (CORBA::Object_ptr obj);
public:
    BOAImpl (CORBA::ORB_ptr, int &argc, char **argv);
    ~BOAImpl ();

    CORBA::Object_ptr create (const ReferenceData &,
                              CORBA::InterfaceDef *,
                              CORBA::ImplementationDef *,
                              CORBA::ImplementationBase * = __null,
                              const char *repoid = 0);

    CORBA::Boolean restoring ();
    CORBA::Object_ptr restore (CORBA::Object_ptr,
                               const ReferenceData &,
                               CORBA::InterfaceDef *,
                               CORBA::ImplementationDef *,
                               CORBA::ImplementationBase *);
    CORBA::ORB_ptr orb ();
    const char *impl_name ();
    void save_objects ();
    void save_object (ObjectRecord *rec);
    void dispose_objects ();
    void dispose_object (ObjectRecord *rec);
    CORBA::Boolean load_object (ObjectRecord *rec);
    void answer_invoke (MsgId, CORBA::Object_ptr,
                        CORBA::ORBRequest *,
                        CORBA::InvokeStatus);

    void dispose (CORBA::Object_ptr);
    ReferenceData *get_id (CORBA::Object_ptr);
    void change_implementation (CORBA::Object_ptr,
                                CORBA::ImplementationDef *);
    CORBA::Principal_ptr get_principal (CORBA::Object_ptr,
                                        CORBA::Environment_ptr);

    void impl_is_ready (CORBA::ImplementationDef *);
    void deactivate_impl (CORBA::ImplementationDef *);
    void obj_is_ready (CORBA::Object_ptr, CORBA::ImplementationDef *);
    void deactivate_obj (CORBA::Object_ptr);


    const char *get_oaid () const;
    CORBA::Boolean has_object (CORBA::Object_ptr);
    CORBA::Boolean is_local () const;

    CORBA::ImplementationDef *get_impl (CORBA::Object_ptr);
    CORBA::InterfaceDef *get_iface (CORBA::Object_ptr);

    CORBA::Boolean invoke (MsgId, CORBA::Object_ptr,
                           CORBA::ORBRequest *,
                           CORBA::Principal_ptr,
                           CORBA::Boolean response_exp = 1);
    CORBA::Boolean bind (MsgId, const char *repoid,
                         const CORBA::ORB::ObjectTag &,
                         CORBA::Address *addr);
    CORBA::Boolean locate (MsgId, CORBA::Object_ptr);
    CORBA::Object_ptr skeleton (CORBA::Object_ptr);
    void cancel (MsgId);
    void shutdown (CORBA::Boolean wait_for_completion);

    friend class BOAServImpl;
};

class BOAServImpl : virtual public CORBA::OAServer_skel {
    BOAImpl *_boa;
public:
    BOAServImpl (BOAImpl *boa);
    ~BOAServImpl ();

    void restore_request (const CORBA::OAServer::ObjSeq &objs);
    void obj_inactive (CORBA::Object_ptr obj);
    void impl_inactive ();
};

}
# 64 "../include/mico/impl.h" 2
# 1 "../include/mico/iop.h" 1
# 27 "../include/mico/iop.h"
namespace MICO {

class GIOPCodec;

class GIOPInContext {
    CORBA::DataDecoder *_dc;
    CORBA::Buffer *_buf;
    CORBA::Boolean _delete_buf;
public:
    GIOPInContext (GIOPCodec *, CORBA::Buffer *,
                   CORBA::CodeSetCoder *csc = 0);
    ~GIOPInContext ();
    void converters (CORBA::CodeSetCoder *csc);
    CORBA::DataDecoder *dc()
    { return _dc; }

    void buffer (CORBA::Buffer *);
    CORBA::DataDecoder *_retn();
};

class GIOPOutContext {
    CORBA::DataEncoder *_ec;
    CORBA::Buffer *_buf;
    CORBA::Boolean _delete_buf;
public:
    GIOPOutContext (GIOPCodec *, CORBA::CodeSetCoder *csc = 0);
    GIOPOutContext (CORBA::DataEncoder *);
    ~GIOPOutContext ();
    void converters (CORBA::CodeSetCoder *csc);
    CORBA::DataEncoder *ec()
    { return _ec; }

    void reset ();

    CORBA::Buffer *_retn();
};




class GIOPCodec;
typedef GIOPCodec *GIOPCodec_ptr;
typedef ObjVar<GIOPCodec> GIOPCodec_var;

class GIOPCodec : public CORBA::ServerlessObject {
    CORBA::DataDecoder *_dc_proto;
    CORBA::DataEncoder *_ec_proto;
    CORBA::ULong _headerlen;
    CORBA::ULong _size_offset;
    CORBA::UShort _giop_ver;
    CORBA::CodeSetCoder * _conv;
    CORBA::Codeset::CodesetId _csid;
    CORBA::Codeset::CodesetId _wcsid;
    CORBA::Boolean _codesets_sent;

    CORBA::ULong put_header (GIOPOutContext &out, CORBA::GIOP::MsgType);
    void put_size (GIOPOutContext &out, CORBA::ULong key);
    void put_contextlist (GIOPOutContext &out,
                          const CORBA::IOP::ServiceContextList &ctx,
                          CORBA::Boolean codesets = 0);
    void put_target (GIOPOutContext &out, CORBA::Object_ptr obj);
    CORBA::Boolean put_args (GIOPOutContext &out, CORBA::ORBRequest *,
                             CORBA::Boolean inp);

    CORBA::Boolean get_contextlist (GIOPInContext &in,
                                    CORBA::IOP::ServiceContextList &ctx,
                                    CORBA::Boolean codesets = 0);
    CORBA::Boolean get_target (GIOPInContext &in, CORBA::Object_ptr obj);
public:
    GIOPCodec (CORBA::DataDecoder *dc, CORBA::DataEncoder *ec,
               CORBA::UShort giop_ver = 0x0100);
    ~GIOPCodec ();

    CORBA::DataDecoder *dc_proto()
    { return _dc_proto; }

    CORBA::DataEncoder *ec_proto()
    { return _ec_proto; }

    CORBA::UShort version () const
    { return _giop_ver; }

    CORBA::ULong header_length ()
    { return _headerlen; }

    CORBA::CodeSetCoder * converter ()
    { return _conv; }

    CORBA::Codeset::CodesetId csid ()
    { return _csid; }

    CORBA::Codeset::CodesetId wcsid ()
    { return _wcsid; }

    CORBA::Boolean setup_codeset_ids (CORBA::Object_ptr);

    CORBA::Boolean put_invoke_request (GIOPOutContext &out,
                                       CORBA::ULong req_id,
                                       CORBA::Octet response_flags,
                                       CORBA::Object_ptr obj,
                                       CORBA::ORBRequest *req,
                                       CORBA::Principal_ptr pr);

    CORBA:: Boolean put_invoke_reply (GIOPOutContext &out,
                                      CORBA::ULong req_id,
                                      CORBA::GIOP::ReplyStatusType,
                                      CORBA::Object_ptr obj,
                                      CORBA::ORBRequest *req,
                                      CORBA::GIOP::AddressingDisposition);

    CORBA::Boolean put_invoke_reply_offset (GIOPOutContext &out,
                                            CORBA::ORBRequest *req);

    CORBA::Boolean put_cancel_request (GIOPOutContext &out,
                                       CORBA::ULong req_id);

    CORBA::Boolean put_locate_request (GIOPOutContext &out,
                                       CORBA::ULong req_id,
                                       CORBA::Object_ptr obj);

    CORBA::Boolean put_locate_reply (GIOPOutContext &out,
                                     CORBA::ULong req_id,
                                     CORBA::GIOP::LocateStatusType,
                                     CORBA::Object_ptr obj,
                                     CORBA::GIOP::AddressingDisposition);

    CORBA::Boolean put_bind_request (GIOPOutContext &out,
                                     CORBA::ULong req_id,
                                     const char *repoid,
                                     const CORBA::ORB::ObjectTag &);

    CORBA::Boolean put_bind_reply (GIOPOutContext &out,
                                   CORBA::ULong req_id,
                                   CORBA::GIOP::LocateStatusType,
                                   CORBA::Object_ptr obj);

    CORBA::Boolean put_close_msg (GIOPOutContext &out);

    CORBA::Boolean put_error_msg (GIOPOutContext &out);

    CORBA::Boolean get_header (GIOPInContext &in, CORBA::GIOP::MsgType &,
                               CORBA::ULong &sz, CORBA::Octet &flags);
    CORBA::Boolean check_header (GIOPInContext &in, CORBA::GIOP::MsgType &,
                                 CORBA::ULong &sz, CORBA::Octet &flags);

    CORBA::Boolean get_invoke_request (GIOPInContext &in,
                                       CORBA::ULong &req_id,
                                       CORBA::Octet &response_flags,
                                       CORBA::Object_ptr obj,
                                       CORBA::ORBRequest * &req,
                                       CORBA::Principal_ptr pr);


    CORBA::Boolean get_invoke_reply1 (GIOPInContext &in,
                                      CORBA::ULong &req_id,
                                      CORBA::GIOP::ReplyStatusType &,
                                      CORBA::IOP::ServiceContextList &ctx);

    CORBA::Boolean get_invoke_reply2 (GIOPInContext &in,
                                      CORBA::ULong req_id,
                                      CORBA::GIOP::ReplyStatusType,
                                      CORBA::Object_ptr &obj,
                                      CORBA::ORBRequest *req,
                                      CORBA::GIOP::AddressingDisposition &,
                                      CORBA::IOP::ServiceContextList &ctx);

    CORBA::Boolean get_cancel_request (GIOPInContext &in,
                                       CORBA::ULong &req_id);

    CORBA::Boolean get_locate_request (GIOPInContext &in,
                                       CORBA::ULong &req_id,
                                       CORBA::Object_ptr obj);

    CORBA::Boolean get_locate_reply (GIOPInContext &in,
                                     CORBA::ULong &req_id,
                                     CORBA::GIOP::LocateStatusType &,
                                     CORBA::Object_ptr &obj,
                                     CORBA::GIOP::AddressingDisposition &);

    CORBA::Boolean get_bind_request (GIOPInContext &in,
                                     CORBA::String_out repoid,
                                     CORBA::ORB::ObjectTag &);

    CORBA::Boolean get_bind_reply (GIOPInContext &in,
                                   CORBA::GIOP::LocateStatusType &,
                                   CORBA::Object_ptr &obj);

    CORBA::Boolean get_close_msg (GIOPInContext &in);

    CORBA::Boolean get_error_msg (GIOPInContext &in);

    CORBA::Boolean get_fragment_header (GIOPInContext &in,
                                        CORBA::ULong &req_id,
                                        CORBA::Boolean &has_id);


    static GIOPCodec_ptr _duplicate (GIOPCodec_ptr o)
    {
        if (o)
            o->_ref();
        return o;
    }
    static GIOPCodec_ptr _nil ()
    {
        return 0;
    }
};


class GIOPRequest : public CORBA::ORBRequest {
    string _opname;

    CORBA::DataDecoder *_idc;
    CORBA::ULong _istart;

    CORBA::DataEncoder *_oec;
    CORBA::DataDecoder *_odc;
    CORBA::ULong _ostart;
    CORBA::Buffer _obuf;

    GIOPCodec_ptr _codec;

    CORBA::Boolean _is_except;
public:
    GIOPRequest (const char *op, CORBA::DataDecoder *indata, GIOPCodec *);
    ~GIOPRequest ();

    const char *op_name();
    CORBA::UShort version () const
    { return _codec->version (); }

    CORBA::Boolean get_in_args (CORBA::NVList_ptr iparams,
                                CORBA::Context_ptr &ctx);
    CORBA::Boolean get_in_args (StaticAnyList *iparams,
                                CORBA::Context_ptr &ctx);
    CORBA::Boolean get_in_args (CORBA::DataEncoder *);

    CORBA::Boolean get_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams,
                                 CORBA::Exception *&ex);
    CORBA::Boolean get_out_args (CORBA::StaticAny *res, StaticAnyList *oparams,
                                 CORBA::Exception *&ex);
    CORBA::Boolean get_out_args (CORBA::DataEncoder *,
                                 CORBA::Boolean &is_except);

    CORBA::Boolean set_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams);
    CORBA::Boolean set_out_args (CORBA::StaticAny *res,
                                 StaticAnyList *oparams);
    void set_out_args (CORBA::Exception *ex);
    CORBA::Boolean set_out_args (CORBA::DataDecoder *,
                                 CORBA::Boolean is_except);

    CORBA::Boolean copy_out_args (CORBA::ORBRequest *);
    CORBA::Boolean copy_in_args (CORBA::ORBRequest *);

    const char *type ();
    CORBA::ByteOrder input_byteorder ();
    CORBA::ByteOrder output_byteorder ();
    CORBA::CodeSetCoder * converter ();

    static GIOPRequest* _nil ()
    {
        return 0;
    }
    static GIOPRequest* _duplicate (GIOPRequest *o)
    {
        if (o)
            o->_ref();
        return o;
    }
};


class GIOPSimpleProf : public CORBA::IORProfile {
public:
    CORBA::Octet *_objkey;
    CORBA::ULong _length;
public:
    GIOPSimpleProf ();
    GIOPSimpleProf (const GIOPSimpleProf &);
    ~GIOPSimpleProf ();
    GIOPSimpleProf &operator= (const GIOPSimpleProf &);

    void encode (CORBA::DataEncoder &) const;
    const CORBA::Address *addr () const;
    ProfileId id () const;
    ProfileId encode_id () const;
    void objectkey (CORBA::Octet *, CORBA::Long length);
    const CORBA::Octet *objectkey (CORBA::Long &length) const;
    CORBA::Boolean reachable ();
    void print (ostream &) const;

    CORBA::IORProfile *clone () const;
    CORBA::Long compare (const CORBA::IORProfile &) const;
    CORBA::Boolean operator== (const CORBA::IORProfile &) const;
    CORBA::Boolean operator< (const CORBA::IORProfile &) const;
};


struct GIOPConnCallback;

class GIOPConn : public CORBA::TransportCallback,
                 public CORBA::DispatcherCallback {
    CORBA::Dispatcher *_disp;
    CORBA::Transport *_transp;
    list<CORBA::Buffer *> _outbufs;
    CORBA::Buffer *_inbufs;
    CORBA::Buffer *_inbuf, *_infrag;
    CORBA::ULong _inlen;
    CORBA::Octet _inflags;
    GIOPConnCallback *_cb;
    GIOPCodec_ptr _codec;
    CORBA::ORB_ptr _orb;
    CORBA::Long _refcnt;
    CORBA::Long _idle_tmout;
    CORBA::Boolean _have_tmout;
    CORBA::Boolean _have_wselect;
    GIOPInContext _inctx;

    void check_idle ();
    void check_busy ();

    void do_write ();
public:
    void do_read ();

    GIOPConn (CORBA::ORB_ptr, CORBA::Transport *, GIOPConnCallback *,
              GIOPCodec *, CORBA::Long tmout = 0);
    virtual ~GIOPConn ();

    virtual void callback (CORBA::Transport *,
                           CORBA::TransportCallback::Event);
    virtual void callback (CORBA::Dispatcher *,
                           CORBA::DispatcherCallback::Event);

    void ref ();
    CORBA::Boolean deref (CORBA::Boolean all = 0);

    void output (CORBA::Buffer *);
    CORBA::Buffer *input ();
    void flush ();
    CORBA::Boolean check_events ();

    CORBA::Transport *transport ()
    { return _transp; }

    GIOPCodec *codec ()
    { return _codec; }

    void cancel (CORBA::ULong reqid);
    void buffering (CORBA::Boolean dobuffering);
};

struct GIOPConnCallback {
    enum Event { InputReady, Closed, Idle };
    virtual CORBA::Boolean callback (GIOPConn *, Event) = 0;
    virtual ~GIOPConnCallback ();
};


class IIOPProxyInvokeRec {
public:
    typedef CORBA::ULong MsgId;
    typedef CORBA::Codeset::CodesetId CodesetId;
private:
    MsgId _id;
    GIOPConn *_conn;
    CORBA::ORBRequest *_req;

public:
    IIOPProxyInvokeRec ()
    {}

    ~IIOPProxyInvokeRec ()
    {}

    void free ()
    {}

    void init (MsgId idval, GIOPConn *connval, CORBA::ORBRequest *req = 0)
    {
        _id = idval;
        _conn = connval;
        _req = req;
    }

    GIOPConn *conn () const
    { return _conn; }

    CORBA::ORBRequest *request () const
    { return _req; }

    MsgId id () const
    { return _id; }
};

class IIOPProxy : public CORBA::ObjectAdapter, public GIOPConnCallback {
    typedef map<MsgId, IIOPProxyInvokeRec *, less<MsgId> > MapIdConn;

    struct addrcomp :
        binary_function<const CORBA::Address *, const CORBA::Address *, bool> {
        bool operator() (const CORBA::Address *a1,
                         const CORBA::Address *a2) const
        { return a1->compare (*a2) < 0; }
    };
    typedef map<const CORBA::Address *, GIOPConn *, addrcomp> MapAddrConn;
    typedef map<const CORBA::IORProfile *, GIOPConn *,
      less<const CORBA::IORProfile *> > MapProfConn;
    typedef vector<CORBA::IORProfile::ProfileId> ProfIdVec;

    ProfIdVec _valid_profiles;
    MapIdConn _ids;
    MapAddrConn _conns;
    MapProfConn _prof_conns;
    CORBA::ORB_ptr _orb;
    CORBA::UShort _giop_ver;

    IIOPProxyInvokeRec *_cache_rec;
    CORBA::Boolean _cache_used;

    static CORBA::Boolean _isblocking;

    IIOPProxyInvokeRec *create_invoke ();
    IIOPProxyInvokeRec *get_invoke (MsgId id);
    void add_invoke (IIOPProxyInvokeRec *rec);
    void del_invoke (MsgId id);
    void abort_invoke (MsgId id);
    void redo_invoke (MsgId id);

    GIOPConn *make_conn (CORBA::Object_ptr);
    GIOPConn *make_conn (const CORBA::Address *, CORBA::Boolean create = 1,
                         CORBA::UShort version = 0);
    void kill_conn (GIOPConn *, CORBA::Boolean redo = 0);
    void conn_error (GIOPConn *, CORBA::Boolean send_error = 1);

    CORBA::Boolean handle_input (GIOPConn *);
    void exec_invoke_reply (GIOPInContext &, CORBA::ULong req_id,
                            CORBA::GIOP::ReplyStatusType,
                            CORBA::Object_ptr, CORBA::ORBRequest *,
                            CORBA::GIOP::AddressingDisposition,
                            GIOPConn *conn);
    CORBA::Boolean handle_invoke_reply (GIOPConn *conn, GIOPInContext &);
    CORBA::Boolean handle_locate_reply (GIOPConn *conn, GIOPInContext &);
public:
    IIOPProxy (CORBA::ORB_ptr,
               CORBA::UShort giop_ver = 0x0100);
    ~IIOPProxy ();

    static void block (CORBA::Boolean b)
    {
        _isblocking = b;
    }
    static CORBA::Boolean isblocking ()
    {
        return _isblocking;
    }

    void register_profile_id (CORBA::ULong id);
    void unregister_profile_id (CORBA::ULong id);

    const char *get_oaid () const;
    CORBA::Boolean has_object (CORBA::Object_ptr);
    CORBA::Boolean is_local () const;

    CORBA::Boolean invoke (MsgId, CORBA::Object_ptr,
                           CORBA::ORBRequest *,
                           CORBA::Principal_ptr,
                           CORBA::Boolean repsonse_exp);
    CORBA::Boolean bind (MsgId, const char *repoid,
                         const CORBA::ORB::ObjectTag &,
                         CORBA::Address *addr);
    CORBA::Boolean locate (MsgId, CORBA::Object_ptr);
    CORBA::Object_ptr skeleton (CORBA::Object_ptr);
    void cancel (MsgId);
    void shutdown (CORBA::Boolean wait_for_completion);

    void answer_invoke (CORBA::ULong, CORBA::Object_ptr,
                        CORBA::ORBRequest *,
                        CORBA::InvokeStatus);

    CORBA::Boolean callback (GIOPConn *, GIOPConnCallback::Event);
};


class IIOPServerInvokeRec {
public:
    typedef CORBA::ULong MsgId;
private:
    CORBA::ORBRequest *_req;
    CORBA::Object_ptr _obj;
    CORBA::Principal_ptr _pr;
    MsgId _orbid, _reqid;
    GIOPConn *_conn;
public:
    IIOPServerInvokeRec ();
    ~IIOPServerInvokeRec ();
    void free ();

    void init_invoke (GIOPConn *conn, MsgId reqid, MsgId orbid,
                      CORBA::ORBRequest *req, CORBA::Object_ptr obj,
                      CORBA::Principal_ptr pr);
    void init_locate (GIOPConn *conn, MsgId reqid, MsgId orbid,
                      CORBA::Object_ptr obj);

    CORBA::ORBRequest *req()
    { return _req; }

    MsgId orbid()
    { return _orbid; }

    void orbid (MsgId id)
    { _orbid = id; }

    MsgId reqid()
    { return _reqid; }

    GIOPConn *conn()
    { return _conn; }
};

class IIOPServer : public CORBA::ObjectAdapter,
                   public CORBA::ORBCallback, public GIOPConnCallback,
                   public CORBA::TransportServerCallback {
    typedef CORBA::ULong MsgId;
    typedef map<MsgId, IIOPServerInvokeRec *, less<MsgId> > MapIdConn;
    typedef list<GIOPConn *> ListConn;
    typedef vector<CORBA::TransportServer *> VecTranspServ;

    VecTranspServ _tservers;
    ListConn _conns;
    MapIdConn _orbids;
    CORBA::ORB_ptr _orb;

    IIOPServerInvokeRec *_cache_rec;
    CORBA::Boolean _cache_used;
    CORBA::UShort _iiop_ver;

    IIOPServerInvokeRec *create_invoke();
    IIOPServerInvokeRec *get_invoke_reqid (MsgId, GIOPConn *conn);
    IIOPServerInvokeRec *get_invoke_orbid (MsgId);
    void add_invoke (IIOPServerInvokeRec *);
    void del_invoke_reqid (MsgId, GIOPConn *conn);
    void del_invoke_orbid (MsgId);
    void abort_invoke_orbid (MsgId);

    void kill_conn (GIOPConn *);
    void conn_error (GIOPConn *, CORBA::Boolean send_error = 1);
    void conn_closed (GIOPConn *);

    CORBA::Boolean handle_input (GIOPConn *);
    MsgId exec_invoke_request (GIOPInContext &, CORBA::Object_ptr,
                               CORBA::ORBRequest *,
                               CORBA::Principal_ptr, CORBA::Boolean resp_exp,
                               GIOPConn *conn,
                               MsgId msgid);
    CORBA::Boolean handle_invoke_request (GIOPConn *conn, GIOPInContext &);
    CORBA::Boolean handle_locate_request (GIOPConn *conn, GIOPInContext &);
    CORBA::Boolean handle_cancel_request (GIOPConn *conn, GIOPInContext &);

    void handle_invoke_reply (MsgId msgid);
    void handle_locate_reply (MsgId msgid);
    void handle_bind_reply (MsgId msgid);
public:
    IIOPServer (CORBA::ORB_ptr, CORBA::UShort iiop_ver = 0x0100);
    ~IIOPServer ();

    CORBA::Boolean listen (CORBA::Address *, CORBA::Address *);
    CORBA::Boolean listen ();


    const char *get_oaid () const;
    CORBA::Boolean has_object (CORBA::Object_ptr);
    CORBA::Boolean is_local () const;

    CORBA::Boolean invoke (MsgId, CORBA::Object_ptr,
                           CORBA::ORBRequest *,
                           CORBA::Principal_ptr,
                           CORBA::Boolean repsonse_exp);
    CORBA::Boolean bind (MsgId, const char *repoid,
                         const CORBA::ORB::ObjectTag &,
                         CORBA::Address *addr);
    CORBA::Boolean locate (MsgId, CORBA::Object_ptr);
    CORBA::Object_ptr skeleton (CORBA::Object_ptr);
    void cancel (MsgId);
    void shutdown (CORBA::Boolean wait_for_completion);

    void answer_invoke (CORBA::ULong, CORBA::Object_ptr,
                        CORBA::ORBRequest *,
                        CORBA::InvokeStatus);


    void callback (CORBA::ORB_ptr, MsgId, CORBA::ORBCallback::Event);
    CORBA::Boolean callback (GIOPConn *, GIOPConnCallback::Event);
    void callback (CORBA::TransportServer *,
                   CORBA::TransportServerCallback::Event);
};

}
# 65 "../include/mico/impl.h" 2
# 1 "../include/mico/policy_impl.h" 1
# 27 "../include/mico/policy_impl.h"
namespace MICO {

class Policy_impl : virtual public CORBA::Policy {
    CORBA::PolicyType pt;
protected:
    Policy_impl (CORBA::PolicyType);
public:
    virtual ~Policy_impl ();
    CORBA::PolicyType policy_type ();
    void destroy ();
};

class DomainManager_impl : virtual public CORBA::DomainManager {


public:
    DomainManager_impl ();
    virtual ~DomainManager_impl ();

    CORBA::Policy_ptr get_domain_policy (CORBA::PolicyType policy_type);
    void set_domain_policy (CORBA::Policy_ptr policy);
    CORBA::DomainManager_ptr copy ();
};

class ConstructionPolicy_impl : virtual public Policy_impl,
                                virtual public CORBA::ConstructionPolicy {
    typedef map<string, CORBA::Boolean, less<string> > IdConstrMap;
    IdConstrMap _constr;
public:
    ConstructionPolicy_impl ();
    virtual ~ConstructionPolicy_impl ();

    void make_domain_manager (CORBA::InterfaceDef_ptr object_type,
                              CORBA::Boolean constr_policy);

    CORBA::Boolean constr_policy (CORBA::Object_ptr object);

    CORBA::Policy_ptr copy ();

    virtual void *_narrow_helper (const char *rid)
    {
        return this->CORBA::ConstructionPolicy::_narrow_helper(rid);
    }
};

class TransportPrefPolicy_impl :
    virtual public Policy_impl,
    virtual public MICOPolicy::TransportPrefPolicy
{
    ProfileTagSeq _prefs;
public:
    TransportPrefPolicy_impl (const ProfileTagSeq &prefs);
    TransportPrefPolicy_impl ();
    virtual ~TransportPrefPolicy_impl ();

    ProfileTagSeq *preferences();
    void preferences (const ProfileTagSeq &prefs);
    ProfileTagSeq *preferences_nocopy();

    CORBA::Policy_ptr copy ();

    virtual void *_narrow_helper (const char *rid)
    {
        return this->MICOPolicy::TransportPrefPolicy::_narrow_helper(rid);
    }
};

class BidirectionalPolicy_impl :
    virtual public Policy_impl,
    virtual public BiDirPolicy::BidirectionalPolicy
{
    BiDirPolicy::BidirectionalPolicyValue _value;
public:
    BidirectionalPolicy_impl (BiDirPolicy::BidirectionalPolicyValue);
    BidirectionalPolicy_impl ();
    virtual ~BidirectionalPolicy_impl ();

    BiDirPolicy::BidirectionalPolicyValue value();

    CORBA::Policy_ptr copy ();

    virtual void *_narrow_helper (const char *rid)
    {
        return this->BiDirPolicy::BidirectionalPolicy::_narrow_helper(rid);
    }
};

}
# 66 "../include/mico/impl.h" 2
# 32 "address.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "address.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "address.cc" 2





CORBA::AddressParser::~AddressParser ()
{
}

CORBA::Address::~Address ()
{
}






namespace CORBA {
  vector<CORBA::AddressParser *> *Address::parsers = 0;
};




void
CORBA::Address::copy (Address *a)
{
}

CORBA::Address *
CORBA::Address::parse (const char *_a)
{
    if (!parsers)
        return 0;

    string rest, proto, a = _a;

    Long pos = a.find (":");
    if (pos < 0) {
        proto = a;
        rest = "";
    } else {
        proto = a.substr (0, pos);
        rest = a.substr (pos+1);
    }

    ULong i;
    for (i = 0; i < parsers->size(); ++i) {
        if ((*parsers)[i]->has_proto(proto.c_str()))
            break;
    }
    if (i >= parsers->size())
        return 0;
    Address *addr = (*parsers)[i]->parse (rest.c_str(), proto.c_str());
    return addr;
}

void
CORBA::Address::register_parser (AddressParser *ap)
{
    if (!parsers)
        parsers = new vector<CORBA::AddressParser *>;
    parsers->push_back (ap);
}

void
CORBA::Address::unregister_parser (AddressParser *ap)
{
    if (!parsers)
        return;

    for (ULong i = 0; i < parsers->size(); ) {
        if ((*parsers)[i] == ap)
            parsers->erase (parsers->begin() + i);
        else
            ++i;
    }
}





MICO::LocalAddress::LocalAddress ()
{
}

MICO::LocalAddress::~LocalAddress ()
{
}

string
MICO::LocalAddress::stringify () const
{
    return "local:";
}

const char *
MICO::LocalAddress::proto () const
{
    return "local";
}

CORBA::Transport *
MICO::LocalAddress::make_transport () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 141, __PRETTY_FUNCTION__), 0)));
    return __null;
}

CORBA::TransportServer *
MICO::LocalAddress::make_transport_server () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 148, __PRETTY_FUNCTION__), 0)));
    return __null;
}

CORBA::IORProfile *
MICO::LocalAddress::make_ior_profile (CORBA::Octet *key,
                                      CORBA::ULong keylen,
                                      const CORBA::MultiComponent &,
                                      CORBA::UShort version) const
{
    return new LocalProfile (key, keylen);
}

CORBA::Boolean
MICO::LocalAddress::is_local () const
{
    return 1;
}

CORBA::Address *
MICO::LocalAddress::clone () const
{
    return new LocalAddress;
}

CORBA::Long
MICO::LocalAddress::compare (const CORBA::Address &a) const
{
    return strcmp (proto(), a.proto());
}

CORBA::Boolean
MICO::LocalAddress::operator== (const CORBA::Address &a) const
{
    return compare (a) == 0;
}

CORBA::Boolean
MICO::LocalAddress::operator< (const CORBA::Address &a) const
{
    return compare (a) < 0;
}





MICO::LocalAddressParser::LocalAddressParser ()
{
    CORBA::Address::register_parser (this);
}

MICO::LocalAddressParser::~LocalAddressParser ()
{
    CORBA::Address::unregister_parser (this);
}

CORBA::Address *
MICO::LocalAddressParser::parse (const char *a, const char *) const
{
    return new LocalAddress;
}

CORBA::Boolean
MICO::LocalAddressParser::has_proto (const char *p) const
{
    return !strcmp ("local", p);
}

static MICO::LocalAddressParser local_address_parser;





CORBA::Boolean MICO::InetAddress::_resolve = 1;

MICO::InetAddress::InetAddress (const char *host, CORBA::UShort port,
                                Family fam)
    : _port (port), _host (host ? host : ""), _family (fam)
{
}

MICO::InetAddress::InetAddress (const vector<CORBA::Octet> &ip,
                                CORBA::UShort port, Family fam)
    : _port (port), _ipaddr (ip), _family (fam)
{
}

MICO::InetAddress::InetAddress (struct sockaddr_in &sin, Family fam)
    : _family (fam)
{
    sockaddr (sin);
}

MICO::InetAddress::~InetAddress ()
{
}

CORBA::Boolean
MICO::InetAddress::resolve_ip () const
{
    if (_ipaddr.size() > 0)
        return 1;
    if (_host.length() == 0)
        return 0;

    InetAddress &me = (InetAddress &)*this;

    CORBA::ULong addr = ::inet_addr ((char *)_host.c_str());
    if (addr != (CORBA::ULong)-1L || _host == string("255.255.255.255")) {
        me._ipaddr.insert (me._ipaddr.begin(),
                           (CORBA::Octet *)&addr,
                           (CORBA::Octet *)&addr + sizeof (CORBA::ULong));
        return 1;
    }

    struct hostent *hent = ::gethostbyname ((char *)_host.c_str());
    if (hent) {
        me._ipaddr.insert (me._ipaddr.begin(),
                           (CORBA::Octet *)hent->h_addr_list[0],
                           (CORBA::Octet *)hent->h_addr_list[0] + hent->h_length);
        return 1;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
      MICO::Logger::Stream (MICO::Logger::Warning)
        << "Warning: cannot resolve hostname '" << _host
        << "' into an IP address." << endl;
    }
    return 0;
}

CORBA::Boolean
MICO::InetAddress::resolve_host () const
{
    if (_host.length() > 0)
        return 1;
    if (_ipaddr.size() == 0)
        return 0;

    InetAddress &me = (InetAddress &)*this;

    if (_resolve) {

        ((void) ((_ipaddr.size() < 2 || &_ipaddr[0] + 1 == &_ipaddr[1]) ? 0 : (__assert_fail ("_ipaddr.size() < 2 || &_ipaddr[0] + 1 == &_ipaddr[1]", "address.cc", 293, __PRETTY_FUNCTION__), 0)));
        struct hostent *hent = ::gethostbyaddr ((char *)&_ipaddr.front(),
                                                _ipaddr.size(), 2);
        if (hent) {
            string s = hent->h_name;
            if ((int)s.find (".") < 0) {

                for (int i = 0; hent->h_aliases[i]; ++i) {
                    s = hent->h_aliases[i];
                    if ((int)s.find (".") >= 0) {
                        me._host = s;
                        break;
                    }
                }
            } else {
                me._host = s;
            }
        }
    }
    if (me._host.length() == 0) {

        me._host = "";
        for (mico_vec_size_type i = 0; i < _ipaddr.size(); ++i) {
            if (i > 0)
                me._host += ".";
            me._host += xdec (_ipaddr[i]);
        }
    }
    return 1;
}

string
MICO::InetAddress::stringify () const
{
    string s = proto();
    s += ":";
    CORBA::Boolean r = resolve_host ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "address.cc", 330, __PRETTY_FUNCTION__), 0)));
    s += _host;
    s += ":";
    s += xdec (_port);
    return s;
}

const char *
MICO::InetAddress::proto () const
{
    switch (_family) {
    case STREAM:
        return "inet";
    case DGRAM:
        return "inet-dgram";
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 346, __PRETTY_FUNCTION__), 0)));
        return 0;
    }
}

CORBA::Transport *
MICO::InetAddress::make_transport () const
{
    switch (_family) {
    case STREAM:
        return new TCPTransport;
    case DGRAM:
        return new UDPTransport;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 360, __PRETTY_FUNCTION__), 0)));
        return 0;
    }
}

CORBA::TransportServer *
MICO::InetAddress::make_transport_server () const
{
    switch (_family) {
    case STREAM:
        return new TCPTransportServer;
    case DGRAM:
        return new UDPTransportServer;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 374, __PRETTY_FUNCTION__), 0)));
        return 0;
    }
}

CORBA::IORProfile *
MICO::InetAddress::make_ior_profile (CORBA::Octet *key,
                                     CORBA::ULong len,
                                     const CORBA::MultiComponent &mc,
                                     CORBA::UShort version) const
{
    struct sockaddr_in sin = sockaddr();
    switch (_family) {
    case STREAM:
        if (sin.sin_addr.s_addr == (__extension__ ({ register unsigned int __v; if (__builtin_constant_p (((uint32_t) 0x00000000))) __v = ((((((uint32_t) 0x00000000)) & 0xff000000) >> 24) | (((((uint32_t) 0x00000000)) & 0x00ff0000) >> 8) | (((((uint32_t) 0x00000000)) & 0x0000ff00) << 8) | (((((uint32_t) 0x00000000)) & 0x000000ff) << 24)); else __asm__ __volatile__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" ((unsigned int) (((uint32_t) 0x00000000))) : "cc"); __v; }))) {
            InetAddress ia (InetAddress::hostname().c_str(), port());
            return new IIOPProfile (key, len, ia, mc, version);
        }
        return new IIOPProfile (key, len, *this, mc, version);
    case DGRAM:
        if (sin.sin_addr.s_addr == (__extension__ ({ register unsigned int __v; if (__builtin_constant_p (((uint32_t) 0x00000000))) __v = ((((((uint32_t) 0x00000000)) & 0xff000000) >> 24) | (((((uint32_t) 0x00000000)) & 0x00ff0000) >> 8) | (((((uint32_t) 0x00000000)) & 0x0000ff00) << 8) | (((((uint32_t) 0x00000000)) & 0x000000ff) << 24)); else __asm__ __volatile__ ("rorw $8, %w0;" "rorl $16, %0;" "rorw $8, %w0" : "=r" (__v) : "0" ((unsigned int) (((uint32_t) 0x00000000))) : "cc"); __v; }))) {
            InetAddress ia (InetAddress::hostname().c_str(), port(),
                            InetAddress::DGRAM);
            return new IIOPProfile (key, len, ia, mc, version,
                                    CORBA::IORProfile::TAG_UDP_IOP);
        }
        return new IIOPProfile (key, len, *this, mc, version,
                                CORBA::IORProfile::TAG_UDP_IOP);
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "address.cc", 403, __PRETTY_FUNCTION__), 0)));
        return 0;
    }
}

CORBA::Boolean
MICO::InetAddress::is_local () const
{
    return 0;
}

CORBA::Address *
MICO::InetAddress::clone () const
{
    return new InetAddress (*this);
}

CORBA::Long
MICO::InetAddress::compare (const CORBA::Address &a) const
{
    CORBA::Long r = strcmp (proto(), a.proto());
    if (r)
        return r;

    const InetAddress &he = (const InetAddress &)a;
    if (_port != he._port)
        return (CORBA::Long)_port - (CORBA::Long)he._port;




    CORBA::Boolean ret = resolve_ip() && he.resolve_ip();
    ((void) ((ret) ? 0 : (__assert_fail ("ret", "address.cc", 435, __PRETTY_FUNCTION__), 0)));

    return mico_vec_compare (_ipaddr, he._ipaddr);
}

CORBA::Boolean
MICO::InetAddress::operator== (const CORBA::Address &a) const
{
    return compare (a) == 0;
}

CORBA::Boolean
MICO::InetAddress::operator< (const CORBA::Address &a) const
{
    return compare (a) < 0;
}

CORBA::Boolean
MICO::InetAddress::valid () const
{
    return resolve_host() && resolve_ip();
}

const char *
MICO::InetAddress::host () const
{
    CORBA::Boolean r = resolve_host();
    ((void) ((r) ? 0 : (__assert_fail ("r", "address.cc", 462, __PRETTY_FUNCTION__), 0)));
    return _host.c_str();
}

void
MICO::InetAddress::host (const char *h)
{
    _ipaddr.erase (_ipaddr.begin(), _ipaddr.end());
    _host = h;
}

const vector<CORBA::Octet> &
MICO::InetAddress::ipaddr () const
{
    CORBA::Boolean r = resolve_ip ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "address.cc", 477, __PRETTY_FUNCTION__), 0)));
    return _ipaddr;
}

void
MICO::InetAddress::ipaddr (const vector<CORBA::Octet> &ip)
{
    _host = "";
    _ipaddr = ip;
}

CORBA::UShort
MICO::InetAddress::port () const
{
    return _port;
}

void
MICO::InetAddress::port (CORBA::UShort p)
{
    _port = p;
}

MICO::InetAddress::Family
MICO::InetAddress::family () const
{
    return _family;
}

void
MICO::InetAddress::family (Family fam)
{
    _family = fam;
}

struct sockaddr_in
MICO::InetAddress::sockaddr () const
{
    CORBA::Boolean r = resolve_ip();
    ((void) ((r) ? 0 : (__assert_fail ("r", "address.cc", 516, __PRETTY_FUNCTION__), 0)));

    struct sockaddr_in sin;
    memset (&sin, 0, sizeof (sin));

    sin.sin_family = 2;
    sin.sin_port = (__extension__ ({ register unsigned short int __v; if (__builtin_constant_p (_port)) __v = ((((_port) >> 8) & 0xff) | (((_port) & 0xff) << 8)); else __asm__ __volatile__ ("rorw $8, %w0" : "=r" (__v) : "0" ((unsigned short int) (_port)) : "cc"); __v; }));


    ((void) ((_ipaddr.size() < 2 || &_ipaddr[0] + 1 == &_ipaddr[1]) ? 0 : (__assert_fail ("_ipaddr.size() < 2 || &_ipaddr[0] + 1 == &_ipaddr[1]", "address.cc", 525, __PRETTY_FUNCTION__), 0)));
    ((void) ((_ipaddr.size() == sizeof (sin.sin_addr.s_addr)) ? 0 : (__assert_fail ("_ipaddr.size() == sizeof (sin.sin_addr.s_addr)", "address.cc", 526, __PRETTY_FUNCTION__), 0)));
    memcpy (&sin.sin_addr.s_addr, &_ipaddr[0], _ipaddr.size());
    return sin;
}

void
MICO::InetAddress::sockaddr (struct sockaddr_in &sin)
{
    _ipaddr.erase (_ipaddr.begin(), _ipaddr.end());
    _ipaddr.insert (_ipaddr.begin(),
                    (CORBA::Octet *)&sin.sin_addr.s_addr,
                    (CORBA::Octet *)(&sin.sin_addr.s_addr+1));
    _port = (__extension__ ({ register unsigned short int __v; if (__builtin_constant_p (sin.sin_port)) __v = ((((sin.sin_port) >> 8) & 0xff) | (((sin.sin_port) & 0xff) << 8)); else __asm__ __volatile__ ("rorw $8, %w0" : "=r" (__v) : "0" ((unsigned short int) (sin.sin_port)) : "cc"); __v; }));
    _host = "";
}

string MICO::InetAddress::hname;

string
MICO::InetAddress::hostname ()
{
    if (hname.length() == 0) {
        char buf[200];
        int r = gethostname (buf, 200);
        ((void) ((r == 0) ? 0 : (__assert_fail ("r == 0", "address.cc", 550, __PRETTY_FUNCTION__), 0)));




        InetAddress a1 (buf, 0);

        InetAddress a2 (a1.ipaddr());
        hname = a2.host();
# 572 "address.cc"
    }
    return hname;
}

vector<CORBA::Octet> MICO::InetAddress::hid;

vector<CORBA::Octet>
MICO::InetAddress::hostid ()
{
    if (hid.size() == 0) {
        char buf[200];
        int r = gethostname (buf, 200);
        ((void) ((r == 0) ? 0 : (__assert_fail ("r == 0", "address.cc", 584, __PRETTY_FUNCTION__), 0)));

        InetAddress a (buf, 0);
        hid = a.ipaddr();
    }
    return hid;
}

CORBA::Boolean
MICO::InetAddress::samehosts (const string &h1, const string &h2)
{

    return h1 == h2;
}

void
MICO::InetAddress::resolve (CORBA::Boolean r)
{
    _resolve = r;
}

CORBA::Boolean
MICO::InetAddress::resolve ()
{
    return _resolve;
}





MICO::InetAddressParser::InetAddressParser ()
{
    CORBA::Address::register_parser (this);
}

MICO::InetAddressParser::~InetAddressParser ()
{
    CORBA::Address::unregister_parser (this);
}

CORBA::Address *
MICO::InetAddressParser::parse (const char *str, const char *proto) const
{
    string s (str);
    CORBA::Long pos = s.find (":");
    if (pos < 0)
        return 0;

    MICO::InetAddress::Family family;
    if (!strcmp (proto, "inet") || !strcmp (proto, "inet-stream"))
        family = MICO::InetAddress::STREAM;
    else if (!strcmp (proto, "inet-dgram"))
        family = MICO::InetAddress::DGRAM;
    else
        return 0;

    string host = s.substr (0, pos);
    string port = s.substr (pos+1);
    CORBA::UShort portnum = atoi (port.c_str());

    InetAddress *ia;

    if (host.length() > 0) {
      ia = new InetAddress (host.c_str(), portnum, family);
    }
    else {
      ia = new InetAddress ("0.0.0.0", portnum, family);
    }
    if (!ia->valid()) {
        delete ia;
        return 0;
    }
    return ia;
}

CORBA::Boolean
MICO::InetAddressParser::has_proto (const char *p) const
{
    return
        !strcmp ("inet", p) ||
        !strcmp ("inet-stream", p) ||
        !strcmp ("inet-dgram", p);
}

static MICO::InetAddressParser inet_address_parser;





MICO::UnixAddress::UnixAddress (struct sockaddr_un &una)
{
    _filename = una.sun_path;
}

MICO::UnixAddress::UnixAddress (const char *filename)
{
    if (filename)
        _filename = filename;
}

MICO::UnixAddress::~UnixAddress ()
{
}

string
MICO::UnixAddress::stringify () const
{
    string s = proto();
    s += ":";
    s += _filename;
    return s;
}

const char *
MICO::UnixAddress::proto () const
{
    return "unix";
}

CORBA::Transport *
MICO::UnixAddress::make_transport () const
{
    return new UnixTransport;
}

CORBA::TransportServer *
MICO::UnixAddress::make_transport_server () const
{
    return new UnixTransportServer;
}

CORBA::IORProfile *
MICO::UnixAddress::make_ior_profile (CORBA::Octet *key,
                                     CORBA::ULong len,
                                     const CORBA::MultiComponent &mc,
                                     CORBA::UShort version) const
{
    return new UIOPProfile (key, len, *this, mc, version);
}

CORBA::Boolean
MICO::UnixAddress::is_local () const
{
    return 0;
}

CORBA::Address *
MICO::UnixAddress::clone () const
{
    return new UnixAddress (*this);
}

CORBA::Long
MICO::UnixAddress::compare (const CORBA::Address &a) const
{
    CORBA::Long r = strcmp (proto(), a.proto());
    if (r)
        return r;

    const UnixAddress &he = (const UnixAddress &)a;

    return _filename.compare (he._filename);
}

CORBA::Boolean
MICO::UnixAddress::operator== (const CORBA::Address &a) const
{
    return compare (a) == 0;
}

CORBA::Boolean
MICO::UnixAddress::operator< (const CORBA::Address &a) const
{
    return compare (a) < 0;
}

const char *
MICO::UnixAddress::filename () const
{
    return _filename.c_str();
}

void
MICO::UnixAddress::filename (const char *filename)
{
    _filename = filename;
}

void
MICO::UnixAddress::sockaddr (struct sockaddr_un &una)
{
    _filename = una.sun_path;
}

struct sockaddr_un
MICO::UnixAddress::sockaddr () const
{
    struct sockaddr_un una;
    memset (&una, 0, sizeof (una));

    una.sun_family = 1;
    ((void) ((_filename.length()+1 <= sizeof (una.sun_path)) ? 0 : (__assert_fail ("_filename.length()+1 <= sizeof (una.sun_path)", "address.cc", 787, __PRETTY_FUNCTION__), 0)));
    strcpy (una.sun_path, _filename.c_str());

    return una;
}





MICO::UnixAddressParser::UnixAddressParser ()
{
    CORBA::Address::register_parser (this);
}

MICO::UnixAddressParser::~UnixAddressParser ()
{
    CORBA::Address::unregister_parser (this);
}

CORBA::Address *
MICO::UnixAddressParser::parse (const char *str, const char *) const
{
    return new UnixAddress (str);
}

CORBA::Boolean
MICO::UnixAddressParser::has_proto (const char *p) const
{
    return !strcmp ("unix", p);
}

static MICO::UnixAddressParser unix_address_parser;
# 3 "orb_all.cc" 2
# 1 "any.cc" 1
# 25 "any.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "any.cc" 2



# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 30 "any.cc" 2
# 1 "../include/mico/impl.h" 1
# 31 "any.cc" 2
# 1 "../include/mico/util.h" 1
# 32 "any.cc" 2
# 1 "../include/mico/throw.h" 1
# 33 "any.cc" 2
# 1 "../include/mico/os-math.h" 1
# 202 "../include/mico/os-math.h"
# 1 "/usr/include/unistd.h" 1 3 4
# 203 "../include/mico/os-math.h" 2
# 1 "/usr/include/signal.h" 1 3 4
# 204 "../include/mico/os-math.h" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 205 "../include/mico/os-math.h" 2



# 1 "/usr/include/math.h" 1 3 4
# 27 "/usr/include/math.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 28 "/usr/include/math.h" 2 3 4

extern "C" {



# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 25 "/usr/include/bits/huge_val.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 26 "/usr/include/bits/huge_val.h" 2 3 4
# 34 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/nan.h" 1 3 4
# 38 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 29 "/usr/include/bits/mathdef.h" 3 4
typedef long double float_t;

typedef long double double_t;
# 41 "/usr/include/math.h" 2 3 4
# 63 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/bits/mathcalls.h" 3 4
extern double acos (double __x); extern double __acos (double __x);

extern double asin (double __x); extern double __asin (double __x);

extern double atan (double __x); extern double __atan (double __x);

extern double atan2 (double __y, double __x); extern double __atan2 (double __y, double __x);


extern double cos (double __x); extern double __cos (double __x);

extern double sin (double __x); extern double __sin (double __x);

extern double tan (double __x); extern double __tan (double __x);



extern void sincos (double __x, double *__sinx, double *__cosx); extern void __sincos (double __x, double *__sinx, double *__cosx);






extern double cosh (double __x); extern double __cosh (double __x);

extern double sinh (double __x); extern double __sinh (double __x);

extern double tanh (double __x); extern double __tanh (double __x);



extern double acosh (double __x); extern double __acosh (double __x);

extern double asinh (double __x); extern double __asinh (double __x);

extern double atanh (double __x); extern double __atanh (double __x);





extern double exp (double __x); extern double __exp (double __x);



extern double exp10 (double __x); extern double __exp10 (double __x);

extern double pow10 (double __x); extern double __pow10 (double __x);



extern double frexp (double __x, int *__exponent); extern double __frexp (double __x, int *__exponent);


extern double ldexp (double __x, int __exponent); extern double __ldexp (double __x, int __exponent);


extern double log (double __x); extern double __log (double __x);


extern double log10 (double __x); extern double __log10 (double __x);


extern double modf (double __x, double *__iptr); extern double __modf (double __x, double *__iptr);



extern double expm1 (double __x); extern double __expm1 (double __x);


extern double log1p (double __x); extern double __log1p (double __x);


extern double logb (double __x); extern double __logb (double __x);




extern double exp2 (double __x); extern double __exp2 (double __x);


extern double log2 (double __x); extern double __log2 (double __x);






extern double pow (double __x, double __y); extern double __pow (double __x, double __y);


extern double sqrt (double __x); extern double __sqrt (double __x);



extern double hypot (double __x, double __y); extern double __hypot (double __x, double __y);




extern double cbrt (double __x); extern double __cbrt (double __x);






extern double ceil (double __x); extern double __ceil (double __x);


extern double fabs (double __x) __attribute__ ((__const__)); extern double __fabs (double __x) __attribute__ ((__const__));


extern double floor (double __x); extern double __floor (double __x);


extern double fmod (double __x, double __y); extern double __fmod (double __x, double __y);




extern int __isinf (double __value) __attribute__ ((__const__));


extern int __finite (double __value) __attribute__ ((__const__));




extern int isinf (double __value) __attribute__ ((__const__));


extern int finite (double __value) __attribute__ ((__const__));







extern double infnan (int __error) __attribute__ ((__const__)); extern double __infnan (int __error) __attribute__ ((__const__));


extern double drem (double __x, double __y); extern double __drem (double __x, double __y);



extern double significand (double __x); extern double __significand (double __x);




extern double copysign (double __x, double __y) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) __attribute__ ((__const__));




extern double nan (__const char *__tagb) __attribute__ ((__const__)); extern double __nan (__const char *__tagb) __attribute__ ((__const__));




extern int __isnan (double __value) __attribute__ ((__const__));



extern int isnan (double __value) __attribute__ ((__const__));


extern double j0 (double); extern double __j0 (double);
extern double j1 (double); extern double __j1 (double);
extern double jn (int, double); extern double __jn (int, double);
extern double y0 (double); extern double __y0 (double);
extern double y1 (double); extern double __y1 (double);
extern double yn (int, double); extern double __yn (int, double);





extern double erf (double); extern double __erf (double);
extern double erfc (double); extern double __erfc (double);
extern double lgamma (double); extern double __lgamma (double);
extern double tgamma (double); extern double __tgamma (double);




extern double gamma (double); extern double __gamma (double);






extern double lgamma_r (double, int *__signgamp); extern double __lgamma_r (double, int *__signgamp);






extern double rint (double __x); extern double __rint (double __x);


extern double nextafter (double __x, double __y) __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) __attribute__ ((__const__));



extern double remainder (double __x, double __y); extern double __remainder (double __x, double __y);



extern double scalb (double __x, double __n); extern double __scalb (double __x, double __n);



extern double scalbn (double __x, int __n); extern double __scalbn (double __x, int __n);


extern int ilogb (double __x); extern int __ilogb (double __x);




extern double scalbln (double __x, long int __n); extern double __scalbln (double __x, long int __n);



extern double nearbyint (double __x); extern double __nearbyint (double __x);



extern double round (double __x); extern double __round (double __x);



extern double trunc (double __x) __attribute__ ((__const__)); extern double __trunc (double __x) __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo); extern double __remquo (double __x, double __y, int *__quo);






extern long int lrint (double __x); extern long int __lrint (double __x);
extern long long int llrint (double __x); extern long long int __llrint (double __x);



extern long int lround (double __x); extern long int __lround (double __x);
extern long long int llround (double __x); extern long long int __llround (double __x);



extern double fdim (double __x, double __y); extern double __fdim (double __x, double __y);


extern double fmax (double __x, double __y); extern double __fmax (double __x, double __y);


extern double fmin (double __x, double __y); extern double __fmin (double __x, double __y);



extern int __fpclassify (double __value)
     __attribute__ ((__const__));


extern int __signbit (double __value)
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z); extern double __fma (double __x, double __y, double __z);
# 64 "/usr/include/math.h" 2 3 4
# 82 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/bits/mathcalls.h" 3 4
extern float acosf (float __x); extern float __acosf (float __x);

extern float asinf (float __x); extern float __asinf (float __x);

extern float atanf (float __x); extern float __atanf (float __x);

extern float atan2f (float __y, float __x); extern float __atan2f (float __y, float __x);


extern float cosf (float __x); extern float __cosf (float __x);

extern float sinf (float __x); extern float __sinf (float __x);

extern float tanf (float __x); extern float __tanf (float __x);



extern void sincosf (float __x, float *__sinx, float *__cosx); extern void __sincosf (float __x, float *__sinx, float *__cosx);






extern float coshf (float __x); extern float __coshf (float __x);

extern float sinhf (float __x); extern float __sinhf (float __x);

extern float tanhf (float __x); extern float __tanhf (float __x);



extern float acoshf (float __x); extern float __acoshf (float __x);

extern float asinhf (float __x); extern float __asinhf (float __x);

extern float atanhf (float __x); extern float __atanhf (float __x);





extern float expf (float __x); extern float __expf (float __x);



extern float exp10f (float __x); extern float __exp10f (float __x);

extern float pow10f (float __x); extern float __pow10f (float __x);



extern float frexpf (float __x, int *__exponent); extern float __frexpf (float __x, int *__exponent);


extern float ldexpf (float __x, int __exponent); extern float __ldexpf (float __x, int __exponent);


extern float logf (float __x); extern float __logf (float __x);


extern float log10f (float __x); extern float __log10f (float __x);


extern float modff (float __x, float *__iptr); extern float __modff (float __x, float *__iptr);



extern float expm1f (float __x); extern float __expm1f (float __x);


extern float log1pf (float __x); extern float __log1pf (float __x);


extern float logbf (float __x); extern float __logbf (float __x);




extern float exp2f (float __x); extern float __exp2f (float __x);


extern float log2f (float __x); extern float __log2f (float __x);






extern float powf (float __x, float __y); extern float __powf (float __x, float __y);


extern float sqrtf (float __x); extern float __sqrtf (float __x);



extern float hypotf (float __x, float __y); extern float __hypotf (float __x, float __y);




extern float cbrtf (float __x); extern float __cbrtf (float __x);






extern float ceilf (float __x); extern float __ceilf (float __x);


extern float fabsf (float __x) __attribute__ ((__const__)); extern float __fabsf (float __x) __attribute__ ((__const__));


extern float floorf (float __x); extern float __floorf (float __x);


extern float fmodf (float __x, float __y); extern float __fmodf (float __x, float __y);




extern int __isinff (float __value) __attribute__ ((__const__));


extern int __finitef (float __value) __attribute__ ((__const__));




extern int isinff (float __value) __attribute__ ((__const__));


extern int finitef (float __value) __attribute__ ((__const__));







extern float infnanf (int __error) __attribute__ ((__const__)); extern float __infnanf (int __error) __attribute__ ((__const__));


extern float dremf (float __x, float __y); extern float __dremf (float __x, float __y);



extern float significandf (float __x); extern float __significandf (float __x);




extern float copysignf (float __x, float __y) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) __attribute__ ((__const__));




extern float nanf (__const char *__tagb) __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) __attribute__ ((__const__));




extern int __isnanf (float __value) __attribute__ ((__const__));



extern int isnanf (float __value) __attribute__ ((__const__));


extern float j0f (float); extern float __j0f (float);
extern float j1f (float); extern float __j1f (float);
extern float jnf (int, float); extern float __jnf (int, float);
extern float y0f (float); extern float __y0f (float);
extern float y1f (float); extern float __y1f (float);
extern float ynf (int, float); extern float __ynf (int, float);





extern float erff (float); extern float __erff (float);
extern float erfcf (float); extern float __erfcf (float);
extern float lgammaf (float); extern float __lgammaf (float);
extern float tgammaf (float); extern float __tgammaf (float);




extern float gammaf (float); extern float __gammaf (float);






extern float lgammaf_r (float, int *__signgamp); extern float __lgammaf_r (float, int *__signgamp);






extern float rintf (float __x); extern float __rintf (float __x);


extern float nextafterf (float __x, float __y) __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) __attribute__ ((__const__));



extern float remainderf (float __x, float __y); extern float __remainderf (float __x, float __y);



extern float scalbf (float __x, float __n); extern float __scalbf (float __x, float __n);



extern float scalbnf (float __x, int __n); extern float __scalbnf (float __x, int __n);


extern int ilogbf (float __x); extern int __ilogbf (float __x);




extern float scalblnf (float __x, long int __n); extern float __scalblnf (float __x, long int __n);



extern float nearbyintf (float __x); extern float __nearbyintf (float __x);



extern float roundf (float __x); extern float __roundf (float __x);



extern float truncf (float __x) __attribute__ ((__const__)); extern float __truncf (float __x) __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo); extern float __remquof (float __x, float __y, int *__quo);






extern long int lrintf (float __x); extern long int __lrintf (float __x);
extern long long int llrintf (float __x); extern long long int __llrintf (float __x);



extern long int lroundf (float __x); extern long int __lroundf (float __x);
extern long long int llroundf (float __x); extern long long int __llroundf (float __x);



extern float fdimf (float __x, float __y); extern float __fdimf (float __x, float __y);


extern float fmaxf (float __x, float __y); extern float __fmaxf (float __x, float __y);


extern float fminf (float __x, float __y); extern float __fminf (float __x, float __y);



extern int __fpclassifyf (float __value)
     __attribute__ ((__const__));


extern int __signbitf (float __value)
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z); extern float __fmaf (float __x, float __y, float __z);
# 83 "/usr/include/math.h" 2 3 4
# 99 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/bits/mathcalls.h" 3 4
extern long double acosl (long double __x); extern long double __acosl (long double __x);

extern long double asinl (long double __x); extern long double __asinl (long double __x);

extern long double atanl (long double __x); extern long double __atanl (long double __x);

extern long double atan2l (long double __y, long double __x); extern long double __atan2l (long double __y, long double __x);


extern long double cosl (long double __x); extern long double __cosl (long double __x);

extern long double sinl (long double __x); extern long double __sinl (long double __x);

extern long double tanl (long double __x); extern long double __tanl (long double __x);



extern void sincosl (long double __x, long double *__sinx, long double *__cosx); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx);






extern long double coshl (long double __x); extern long double __coshl (long double __x);

extern long double sinhl (long double __x); extern long double __sinhl (long double __x);

extern long double tanhl (long double __x); extern long double __tanhl (long double __x);



extern long double acoshl (long double __x); extern long double __acoshl (long double __x);

extern long double asinhl (long double __x); extern long double __asinhl (long double __x);

extern long double atanhl (long double __x); extern long double __atanhl (long double __x);





extern long double expl (long double __x); extern long double __expl (long double __x);



extern long double exp10l (long double __x); extern long double __exp10l (long double __x);

extern long double pow10l (long double __x); extern long double __pow10l (long double __x);



extern long double frexpl (long double __x, int *__exponent); extern long double __frexpl (long double __x, int *__exponent);


extern long double ldexpl (long double __x, int __exponent); extern long double __ldexpl (long double __x, int __exponent);


extern long double logl (long double __x); extern long double __logl (long double __x);


extern long double log10l (long double __x); extern long double __log10l (long double __x);


extern long double modfl (long double __x, long double *__iptr); extern long double __modfl (long double __x, long double *__iptr);



extern long double expm1l (long double __x); extern long double __expm1l (long double __x);


extern long double log1pl (long double __x); extern long double __log1pl (long double __x);


extern long double logbl (long double __x); extern long double __logbl (long double __x);




extern long double exp2l (long double __x); extern long double __exp2l (long double __x);


extern long double log2l (long double __x); extern long double __log2l (long double __x);






extern long double powl (long double __x, long double __y); extern long double __powl (long double __x, long double __y);


extern long double sqrtl (long double __x); extern long double __sqrtl (long double __x);



extern long double hypotl (long double __x, long double __y); extern long double __hypotl (long double __x, long double __y);




extern long double cbrtl (long double __x); extern long double __cbrtl (long double __x);






extern long double ceill (long double __x); extern long double __ceill (long double __x);


extern long double fabsl (long double __x) __attribute__ ((__const__)); extern long double __fabsl (long double __x) __attribute__ ((__const__));


extern long double floorl (long double __x); extern long double __floorl (long double __x);


extern long double fmodl (long double __x, long double __y); extern long double __fmodl (long double __x, long double __y);




extern int __isinfl (long double __value) __attribute__ ((__const__));


extern int __finitel (long double __value) __attribute__ ((__const__));




extern int isinfl (long double __value) __attribute__ ((__const__));


extern int finitel (long double __value) __attribute__ ((__const__));







extern long double infnanl (int __error) __attribute__ ((__const__)); extern long double __infnanl (int __error) __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y); extern long double __dreml (long double __x, long double __y);



extern long double significandl (long double __x); extern long double __significandl (long double __x);




extern long double copysignl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) __attribute__ ((__const__));




extern long double nanl (__const char *__tagb) __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) __attribute__ ((__const__));




extern int __isnanl (long double __value) __attribute__ ((__const__));



extern int isnanl (long double __value) __attribute__ ((__const__));


extern long double j0l (long double); extern long double __j0l (long double);
extern long double j1l (long double); extern long double __j1l (long double);
extern long double jnl (int, long double); extern long double __jnl (int, long double);
extern long double y0l (long double); extern long double __y0l (long double);
extern long double y1l (long double); extern long double __y1l (long double);
extern long double ynl (int, long double); extern long double __ynl (int, long double);





extern long double erfl (long double); extern long double __erfl (long double);
extern long double erfcl (long double); extern long double __erfcl (long double);
extern long double lgammal (long double); extern long double __lgammal (long double);
extern long double tgammal (long double); extern long double __tgammal (long double);




extern long double gammal (long double); extern long double __gammal (long double);






extern long double lgammal_r (long double, int *__signgamp); extern long double __lgammal_r (long double, int *__signgamp);






extern long double rintl (long double __x); extern long double __rintl (long double __x);


extern long double nextafterl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y); extern long double __remainderl (long double __x, long double __y);



extern long double scalbl (long double __x, long double __n); extern long double __scalbl (long double __x, long double __n);



extern long double scalbnl (long double __x, int __n); extern long double __scalbnl (long double __x, int __n);


extern int ilogbl (long double __x); extern int __ilogbl (long double __x);




extern long double scalblnl (long double __x, long int __n); extern long double __scalblnl (long double __x, long int __n);



extern long double nearbyintl (long double __x); extern long double __nearbyintl (long double __x);



extern long double roundl (long double __x); extern long double __roundl (long double __x);



extern long double truncl (long double __x) __attribute__ ((__const__)); extern long double __truncl (long double __x) __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo); extern long double __remquol (long double __x, long double __y, int *__quo);






extern long int lrintl (long double __x); extern long int __lrintl (long double __x);
extern long long int llrintl (long double __x); extern long long int __llrintl (long double __x);



extern long int lroundl (long double __x); extern long int __lroundl (long double __x);
extern long long int llroundl (long double __x); extern long long int __llroundl (long double __x);



extern long double fdiml (long double __x, long double __y); extern long double __fdiml (long double __x, long double __y);


extern long double fmaxl (long double __x, long double __y); extern long double __fmaxl (long double __x, long double __y);


extern long double fminl (long double __x, long double __y); extern long double __fminl (long double __x, long double __y);



extern int __fpclassifyl (long double __value)
     __attribute__ ((__const__));


extern int __signbitl (long double __value)
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z); extern long double __fmal (long double __x, long double __y, long double __z);
# 100 "/usr/include/math.h" 2 3 4
# 113 "/usr/include/math.h" 3 4
extern int signgam;
# 154 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN,

    FP_INFINITE,

    FP_ZERO,

    FP_SUBNORMAL,

    FP_NORMAL

  };
# 236 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 259 "/usr/include/math.h" 3 4
struct __exception



  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };


extern int matherr (struct __exception *__exc) throw ();
# 289 "/usr/include/math.h" 3 4
# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/float.h" 1 3 4
# 290 "/usr/include/math.h" 2 3 4
# 348 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 117 "/usr/include/bits/mathinline.h" 3 4
__inline int
__signbitf (float __x)
{
  __extension__ union { float __f; int __i; } __u = { __f: __x };
  return __u.__i < 0;
}
__inline int
__signbit (double __x)
{
  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
  return __u.__i[1] < 0;
}
__inline int
__signbitl (long double __x)
{
  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
  return (__u.__i[2] & 0x8000) != 0;
}
# 234 "/usr/include/bits/mathinline.h" 3 4
__inline double __sgn (double); __inline double __sgn (double __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } __inline float __sgnf (float); __inline float __sgnf (float __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } __inline long double __sgnl (long double); __inline long double __sgnl (long double __x) { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); }


__inline double __pow2 (double); __inline double __pow2 (double __x) { register long double __value; register long double __exponent; __extension__ long long int __p = (long long int) __x; if (__x == (long double) __p) { __asm __volatile__ ("fscale" : "=t" (__value) : "0" (1.0), "u" (__x)); return __value; } __asm __volatile__ ("fld	%%st(0)\n\t" "frndint			# int(x)\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x)\n\t" "f2xm1			# 2^(fract(x)) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline float __pow2f (float); __inline float __pow2f (float __x) { register long double __value; register long double __exponent; __extension__ long long int __p = (long long int) __x; if (__x == (long double) __p) { __asm __volatile__ ("fscale" : "=t" (__value) : "0" (1.0), "u" (__x)); return __value; } __asm __volatile__ ("fld	%%st(0)\n\t" "frndint			# int(x)\n\t" "fxch\!
n\t" "fsub	%%st(1)		# fract(x)\n\t" "f2xm1			# 2^(fract(x)) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline long double __pow2l (long double); __inline long double __pow2l (long double __x) { register long double __value; register long double __exponent; __extension__ long long int __p = (long long int) __x; if (__x == (long double) __p) { __asm __volatile__ ("fscale" : "=t" (__value) : "0" (1.0), "u" (__x)); return __value; } __asm __volatile__ ("fld	%%st(0)\n\t" "frndint			# int(x)\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x)\n\t" "f2xm1			# 2^(fract(x)) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; }
# 283 "/usr/include/bits/mathinline.h" 3 4
__inline void __sincos (double __x, double *__sinx, double *__cosx);
__inline void
__sincos (double __x, double *__sinx, double *__cosx)
{
  register long double __cosr; register long double __sinr; __asm __volatile__ ("fsincos\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jz	1f\n\t" "fldpi\n\t" "fadd	%%st(0)\n\t" "fxch	%%st(1)\n\t" "2: fprem1\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jnz	2b\n\t" "fstp	%%st(1)\n\t" "fsincos\n\t" "1:" : "=t" (__cosr), "=u" (__sinr) : "0" (__x)); *__sinx = __sinr; *__cosx = __cosr;
}

__inline void __sincosf (float __x, float *__sinx, float *__cosx);
__inline void
__sincosf (float __x, float *__sinx, float *__cosx)
{
  register long double __cosr; register long double __sinr; __asm __volatile__ ("fsincos\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jz	1f\n\t" "fldpi\n\t" "fadd	%%st(0)\n\t" "fxch	%%st(1)\n\t" "2: fprem1\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jnz	2b\n\t" "fstp	%%st(1)\n\t" "fsincos\n\t" "1:" : "=t" (__cosr), "=u" (__sinr) : "0" (__x)); *__sinx = __sinr; *__cosx = __cosr;
}

__inline void __sincosl (long double __x, long double *__sinx,
                              long double *__cosx);
__inline void
__sincosl (long double __x, long double *__sinx, long double *__cosx)
{
  register long double __cosr; register long double __sinr; __asm __volatile__ ("fsincos\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jz	1f\n\t" "fldpi\n\t" "fadd	%%st(0)\n\t" "fxch	%%st(1)\n\t" "2: fprem1\n\t" "fnstsw	%%ax\n\t" "testl	$0x400, %%eax\n\t" "jnz	2b\n\t" "fstp	%%st(1)\n\t" "fsincos\n\t" "1:" : "=t" (__cosr), "=u" (__sinr) : "0" (__x)); *__sinx = __sinr; *__cosx = __cosr;
}
# 328 "/usr/include/bits/mathinline.h" 3 4
__inline long double __expm1l (long double); __inline long double __expm1l (long double __x) { register long double __value; register long double __exponent; register long double __temp; __asm __volatile__ ("fldl2e			# e^x - 1 = 2^(x * log2(e)) - 1\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" "fscale			# 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __asm __volatile__ ("fscale			# 2^int(x * log2(e))\n\t" : "=t" (__temp) : "0" (1.0), "u" (__exponent)); __temp -= 1.0; return __temp + __value; }
# 348 "/usr/include/bits/mathinline.h" 3 4
__inline double exp (double); __inline double exp (double __x) { register long double __value; register long double __exponent; __asm __volatile__ ("fldl2e			# e^x = 2^(x * log2(e))\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline float expf (float); __inline float expf (float __x) { register long double __value; register long double __exponent; __asm __volatile__ ("fldl2e			# e^x = 2^(x * log2(e))\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fs!
cale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline long double expl (long double); __inline long double expl (long double __x) { register long double __value; register long double __exponent; __asm __volatile__ ("fldl2e			# e^x = 2^(x * log2(e))\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; }
__inline long double __expl (long double); __inline long double __expl (long double __x) { register long double __value; register long double __exponent; __asm __volatile__ ("fldl2e			# e^x = 2^(x * log2(e))\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; }


__inline double tan (double); __inline double tan (double __x) { register long double __value; register long double __value2 __attribute__ ((__unused__)); __asm __volatile__ ("fptan" : "=t" (__value2), "=u" (__value) : "0" (__x)); return __value; } __inline float tanf (float); __inline float tanf (float __x) { register long double __value; register long double __value2 __attribute__ ((__unused__)); __asm __volatile__ ("fptan" : "=t" (__value2), "=u" (__value) : "0" (__x)); return __value; } __inline long double tanl (long double); __inline long double tanl (long double __x) { register long double __value; register long double __value2 __attribute__ ((__unused__)); __asm __volatile__ ("fptan" : "=t" (__value2), "=u" (__value) : "0" (__x)); return __value; }
# 367 "/usr/include/bits/mathinline.h" 3 4
__inline double atan2 (double, double); __inline double atan2 (double __y, double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; } __inline float atan2f (float, float); __inline float atan2f (float __y, float __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; } __inline long double atan2l (long double, long double); __inline long double atan2l (long double __y, long double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; }
__inline long double __atan2l (long double, long double); __inline long double __atan2l (long double __y, long double __x) { register long double __value; __asm __volatile__ ("fpatan" : "=t" (__value) : "0" (__x), "u" (__y) : "st(1)"); return __value; }


__inline double fmod (double, double); __inline double fmod (double __x, double __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; } __inline float fmodf (float, float); __inline float fmodf (float __x, float __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; } __inline long double fmodl (long double, long double); __inline long double fmodl (long double __x, long double __y) { register long double __value; __asm __volatile__ ("1:	fprem\n\t" "fnstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value) : "0" (__x), "u" (__y) : "ax", "cc"); return __value; }
# 382 "/usr/include/bits/mathinline.h" 3 4
__inline double pow (double, double); __inline double pow (double __x, double __y) { register long double __value; register long double __exponent; __extension__ long long int __p = (long long int) __y; if (__x == 0.0 && __y > 0.0) return 0.0; if (__y == (double) __p) { long double __r = 1.0; if (__p == 0) return 1.0; if (__p < 0) { __p = -__p; __x = 1.0 / __x; } while (1) { if (__p & 1) __r *= __x; __p >>= 1; if (__p == 0) return __r; __x *= __x; } } __asm __volatile__ ("fyl2x" : "=t" (__value) : "0" (__x), "u" (1.0) : "st(1)"); __asm __volatile__ ("fmul	%%st(1)		# y * log2(x)\n\t" "fst	%%st(1)\n\t" "frndint			# int(y * log2(x))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(y * log2(x))\n\t" "f2xm1			# 2^(fract(y * log2(x))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__y), "1" (__value)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline float powf (float, float); __inline float powf (float __x, floa!
t __y) { register long double __value; register long double __exponent; __extension__ long long int __p = (long long int) __y; if (__x == 0.0 && __y > 0.0) return 0.0; if (__y == (double) __p) { long double __r = 1.0; if (__p == 0) return 1.0; if (__p < 0) { __p = -__p; __x = 1.0 / __x; } while (1) { if (__p & 1) __r *= __x; __p >>= 1; if (__p == 0) return __r; __x *= __x; } } __asm __volatile__ ("fyl2x" : "=t" (__value) : "0" (__x), "u" (1.0) : "st(1)"); __asm __volatile__ ("fmul	%%st(1)		# y * log2(x)\n\t" "fst	%%st(1)\n\t" "frndint			# int(y * log2(x))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(y * log2(x))\n\t" "f2xm1			# 2^(fract(y * log2(x))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__y), "1" (__value)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; } __inline long double powl (long double, long double); __inline long double powl (long double __x, long double __y) { register long double __value; r!
egister long double __exponent; __extension__ long long int __p = (long long int) __y; if (__x == 0.0 && __y > 0.0) return 0.0; if (__y == (double) __p) { long double __r = 1.0; if (__p == 0) return 1.0; if (__p < 0) { __p = -__p; __x = 1.0 / __x; } while (1) { if (__p & 1) __r *= __x; __p >>= 1; if (__p == 0) return __r; __x *= __x; } } __asm __volatile__ ("fyl2x" : "=t" (__value) : "0" (__x), "u" (1.0) : "st(1)"); __asm __volatile__ ("fmul	%%st(1)		# y * log2(x)\n\t" "fst	%%st(1)\n\t" "frndint			# int(y * log2(x))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(y * log2(x))\n\t" "f2xm1			# 2^(fract(y * log2(x))) - 1\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__y), "1" (__value)); __value += 1.0; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__value), "u" (__exponent)); return __value; }
# 426 "/usr/include/bits/mathinline.h" 3 4
__inline double sqrt (double); __inline double sqrt (double __x) { register double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; } __inline float sqrtf (float); __inline float sqrtf (float __x) { register float __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; } __inline long double sqrtl (long double); __inline long double sqrtl (long double __x) { register long double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; }
__inline long double __sqrtl (long double); __inline long double __sqrtl (long double __x) { register long double __result; __asm __volatile__ ("fsqrt" : "=t" (__result) : "0" (__x)); return __result; }


__inline double fabs (double); __inline double fabs (double __x) { return __builtin_fabs (__x); }
__inline float fabsf (float); __inline float fabsf (float __x) { return __builtin_fabsf (__x); }
__inline long double fabsl (long double); __inline long double fabsl (long double __x) { return __builtin_fabsl (__x); }
__inline long double __fabsl (long double); __inline long double __fabsl (long double __x) { return __builtin_fabsl (__x); }






__inline double sin (double); __inline double sin (double __x) { register double __result; __asm __volatile__ ("fsin" : "=t" (__result) : "0" (__x)); return __result; } __inline float sinf (float); __inline float sinf (float __x) { register float __result; __asm __volatile__ ("fsin" : "=t" (__result) : "0" (__x)); return __result; } __inline long double sinl (long double); __inline long double sinl (long double __x) { register long double __result; __asm __volatile__ ("fsin" : "=t" (__result) : "0" (__x)); return __result; }

__inline double cos (double); __inline double cos (double __x) { register double __result; __asm __volatile__ ("fcos" : "=t" (__result) : "0" (__x)); return __result; } __inline float cosf (float); __inline float cosf (float __x) { register float __result; __asm __volatile__ ("fcos" : "=t" (__result) : "0" (__x)); return __result; } __inline long double cosl (long double); __inline long double cosl (long double __x) { register long double __result; __asm __volatile__ ("fcos" : "=t" (__result) : "0" (__x)); return __result; }

__inline double atan (double); __inline double atan (double __x) { register double __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline float atanf (float); __inline float atanf (float __x) { register float __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline long double atanl (long double); __inline long double atanl (long double __x) { register long double __result; __asm __volatile__ ("fld1; fpatan" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; }
__inline double log (double); __inline double log (double __x) { register double __result; __asm __volatile__ ("fldln2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline float logf (float); __inline float logf (float __x) { register float __result; __asm __volatile__ ("fldln2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline long double logl (long double); __inline long double logl (long double __x) { register long double __result; __asm __volatile__ ("fldln2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; }
__inline double log10 (double); __inline double log10 (double __x) { register double __result; __asm __volatile__ ("fldlg2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline float log10f (float); __inline float log10f (float __x) { register float __result; __asm __volatile__ ("fldlg2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline long double log10l (long double); __inline long double log10l (long double __x) { register long double __result; __asm __volatile__ ("fldlg2; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; }

__inline double asin (double); __inline double asin (double __x) { return __atan2l (__x, __sqrtl (1.0 - __x * __x)); } __inline float asinf (float); __inline float asinf (float __x) { return __atan2l (__x, __sqrtl (1.0 - __x * __x)); } __inline long double asinl (long double); __inline long double asinl (long double __x) { return __atan2l (__x, __sqrtl (1.0 - __x * __x)); }
__inline double acos (double); __inline double acos (double __x) { return __atan2l (__sqrtl (1.0 - __x * __x), __x); } __inline float acosf (float); __inline float acosf (float __x) { return __atan2l (__sqrtl (1.0 - __x * __x), __x); } __inline long double acosl (long double); __inline long double acosl (long double __x) { return __atan2l (__sqrtl (1.0 - __x * __x), __x); }

__inline long double __sgn1l (long double); __inline long double __sgn1l (long double __x) { return __x >= 0.0 ? 1.0 : -1.0; }



__inline double sinh (double); __inline double sinh (double __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x); } __inline float sinhf (float); __inline float sinhf (float __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x); } __inline long double sinhl (long double); __inline long double sinhl (long double __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0) + __exm1) * __sgn1l (__x); }



__inline double cosh (double); __inline double cosh (double __x) { register long double __ex = __expl (__x); return 0.5 * (__ex + 1.0 / __ex); } __inline float coshf (float); __inline float coshf (float __x) { register long double __ex = __expl (__x); return 0.5 * (__ex + 1.0 / __ex); } __inline long double coshl (long double); __inline long double coshl (long double __x) { register long double __ex = __expl (__x); return 0.5 * (__ex + 1.0 / __ex); }



__inline double tanh (double); __inline double tanh (double __x) { register long double __exm1 = __expm1l (-__fabsl (__x + __x)); return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x); } __inline float tanhf (float); __inline float tanhf (float __x) { register long double __exm1 = __expm1l (-__fabsl (__x + __x)); return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x); } __inline long double tanhl (long double); __inline long double tanhl (long double __x) { register long double __exm1 = __expm1l (-__fabsl (__x + __x)); return __exm1 / (__exm1 + 2.0) * __sgn1l (-__x); }




__inline double floor (double); __inline double floor (double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } __inline float floorf (float); __inline float floorf (float __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } __inline long double floorl (long double); __inline long double floorl (long double __x) { register long double __value; __volatile unsig!
ned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0400; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; }
# 479 "/usr/include/bits/mathinline.h" 3 4
__inline double ceil (double); __inline double ceil (double __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } __inline float ceilf (float); __inline float ceilf (float __x) { register long double __value; __volatile unsigned short int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; } __inline long double ceill (long double); __inline long double ceill (long double __x) { register long double __value; __volatile unsigned sh!
ort int __cw; __volatile unsigned short int __cwtmp; __asm __volatile ("fnstcw %0" : "=m" (__cw)); __cwtmp = (__cw & 0xf3ff) | 0x0800; __asm __volatile ("fldcw %0" : : "m" (__cwtmp)); __asm __volatile ("frndint" : "=t" (__value) : "0" (__x)); __asm __volatile ("fldcw %0" : : "m" (__cw)); return __value; }
# 497 "/usr/include/bits/mathinline.h" 3 4
__inline double ldexp (double __x, int __y);
__inline double
ldexp (double __x, int __y)
{
  register long double __value; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__x), "u" ((long double) __y)); return __value;
}





__inline double expm1 (double); __inline double expm1 (double __x) { register long double __value; register long double __exponent; register long double __temp; __asm __volatile__ ("fldl2e			# e^x - 1 = 2^(x * log2(e)) - 1\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" "fscale			# 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __asm __volatile__ ("fscale			# 2^int(x * log2(e))\n\t" : "=t" (__temp) : "0" (1.0), "u" (__exponent)); __temp -= 1.0; return __temp + __value; } __inline float expm1f (float); __inline float expm1f (float __x) { register long double __value; register long double __exponent; register long double __temp; __asm __volatile__ ("fldl2e			# e^x - 1 = 2^(x * log2(e)) - 1\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub!
	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" "fscale			# 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __asm __volatile__ ("fscale			# 2^int(x * log2(e))\n\t" : "=t" (__temp) : "0" (1.0), "u" (__exponent)); __temp -= 1.0; return __temp + __value; } __inline long double expm1l (long double); __inline long double expm1l (long double __x) { register long double __value; register long double __exponent; register long double __temp; __asm __volatile__ ("fldl2e			# e^x - 1 = 2^(x * log2(e)) - 1\n\t" "fmul	%%st(1)		# x * log2(e)\n\t" "fst	%%st(1)\n\t" "frndint			# int(x * log2(e))\n\t" "fxch\n\t" "fsub	%%st(1)		# fract(x * log2(e))\n\t" "f2xm1			# 2^(fract(x * log2(e))) - 1\n\t" "fscale			# 2^(x * log2(e)) - 2^(int(x * log2(e)))\n\t" : "=t" (__value), "=u" (__exponent) : "0" (__x)); __asm __volatile__ ("fscale			# 2^int(x * log2(e))\n\t" : "=t" (__temp) : "0" (1.0), "u" (__exponent)); __temp -= 1.0; ret!
urn __temp + __value; }





__inline double log1p (double); __inline double log1p (double __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; } __inline float log1pf (float); __inline float log1pf (float __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; } __inline long double log1pl (long double); __inline long double log1pl (long double __x) { register long double __value; if (__fabsl (__x) >= 1.0 - 0.5 * 1.41421356237309504880L) __value = logl (1.0 + __x); else __asm __volatile__ ("fldln2\n\t" "fxch\n\t" "fyl2xp1" : "=t" (__value) : "0" (__x) : "st(1)"); return __value; }
# 528 "/usr/include/bits/mathinline.h" 3 4
__inline double asinh (double); __inline double asinh (double __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); } __inline float asinhf (float); __inline float asinhf (float __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); } __inline long double asinhl (long double); __inline long double asinhl (long double __x) { register long double __y = __fabsl (__x); return (log1pl (__y * __y / (__sqrtl (__y * __y + 1.0) + 1.0) + __y) * __sgn1l (__x)); }




__inline double acosh (double); __inline double acosh (double __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); } __inline float acoshf (float); __inline float acoshf (float __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); } __inline long double acoshl (long double); __inline long double acoshl (long double __x) { return logl (__x + __sqrtl (__x - 1.0) * __sqrtl (__x + 1.0)); }


__inline double atanh (double); __inline double atanh (double __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); } __inline float atanhf (float); __inline float atanhf (float __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); } __inline long double atanhl (long double); __inline long double atanhl (long double __x) { register long double __y = __fabsl (__x); return -0.5 * log1pl (-(__y + __y) / (1.0 + __y)) * __sgn1l (__x); }




__inline double hypot (double, double); __inline double hypot (double __x, double __y) { return __sqrtl (__x * __x + __y * __y); } __inline float hypotf (float, float); __inline float hypotf (float __x, float __y) { return __sqrtl (__x * __x + __y * __y); } __inline long double hypotl (long double, long double); __inline long double hypotl (long double __x, long double __y) { return __sqrtl (__x * __x + __y * __y); }

__inline double logb (double); __inline double logb (double __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; } __inline float logbf (float); __inline float logbf (float __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; } __inline long double logbl (long double); __inline long double logbl (long double __x) { register long double __value; register long double __junk; __asm __volatile__ ("fxtract\n\t" : "=t" (__junk), "=u" (__value) : "0" (__x)); return __value; }
# 554 "/usr/include/bits/mathinline.h" 3 4
__inline double log2 (double); __inline double log2 (double __x) { register double __result; __asm __volatile__ ("fld1; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline float log2f (float); __inline float log2f (float __x) { register float __result; __asm __volatile__ ("fld1; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; } __inline long double log2l (long double); __inline long double log2l (long double __x) { register long double __result; __asm __volatile__ ("fld1; fxch; fyl2x" : "=t" (__result) : "0" (__x) : "st(1)"); return __result; }

__inline float ldexpf (float __x, int __y);
__inline float
ldexpf (float __x, int __y)
{
  register long double __value; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__x), "u" ((long double) __y)); return __value;
}

__inline long double ldexpl (long double __x, int __y);
__inline long double
ldexpl (long double __x, int __y)
{
  register long double __value; __asm __volatile__ ("fscale" : "=t" (__value) : "0" (__x), "u" ((long double) __y)); return __value;
}

__inline double fma (double, double, double); __inline double fma (double __x, double __y, double __z) { return (__x * __y) + __z; } __inline float fmaf (float, float, float); __inline float fmaf (float __x, float __y, float __z) { return (__x * __y) + __z; } __inline long double fmal (long double, long double, long double); __inline long double fmal (long double __x, long double __y, long double __z) { return (__x * __y) + __z; }

__inline double rint (double); __inline double rint (double __x) { register double __result; __asm __volatile__ ("frndint" : "=t" (__result) : "0" (__x)); return __result; } __inline float rintf (float); __inline float rintf (float __x) { register float __result; __asm __volatile__ ("frndint" : "=t" (__result) : "0" (__x)); return __result; } __inline long double rintl (long double); __inline long double rintl (long double __x) { register long double __result; __asm __volatile__ ("frndint" : "=t" (__result) : "0" (__x)); return __result; }







__inline long int
lrintf (float __x)
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
__inline long int
lrint (double __x)
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
__inline long int
lrintl (long double __x)
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
# 603 "/usr/include/bits/mathinline.h" 3 4
__inline long long int
llrintf (float __x)
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
__inline long long int
llrint (double __x)
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
__inline long long int
llrintl (long double __x)
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}







__inline double drem (double, double); __inline double drem (double __x, double __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; } __inline float dremf (float, float); __inline float dremf (float __x, float __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; } __inline long double dreml (long double, long double); __inline long double dreml (long double __x, long double __y) { register double __value; register int __clobbered; __asm __volatile__ ("1:	fprem1\n\t" "fstsw	%%ax\n\t" "sahf\n\t" "jp	1b" : "=t" (__value), "=&a" (__clobbered) : "0" (__x), "u" (__y) : "cc"); return __value; }
# 638 "/usr/include/bits/mathinline.h" 3 4
__inline int __finite (double __x) __attribute__ ((__const__));
__inline int
__finite (double __x)
{
  return (__extension__
          (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
             | 0x800fffffu) + 1) >> 31));
}



__inline double __coshm1 (double); __inline double __coshm1 (double __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1; } __inline float __coshm1f (float); __inline float __coshm1f (float __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1; } __inline long double __coshm1l (long double); __inline long double __coshm1l (long double __x) { register long double __exm1 = __expm1l (__fabsl (__x)); return 0.5 * (__exm1 / (__exm1 + 1.0)) * __exm1; }



__inline double __acosh1p (double); __inline double __acosh1p (double __x) { return log1pl (__x + __sqrtl (__x) * __sqrtl (__x + 2.0)); } __inline float __acosh1pf (float); __inline float __acosh1pf (float __x) { return log1pl (__x + __sqrtl (__x) * __sqrtl (__x + 2.0)); } __inline long double __acosh1pl (long double); __inline long double __acosh1pl (long double __x) { return log1pl (__x + __sqrtl (__x) * __sqrtl (__x + 2.0)); }
# 349 "/usr/include/math.h" 2 3 4
# 409 "/usr/include/math.h" 3 4
}
# 209 "../include/mico/os-math.h" 2



# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/float.h" 1 3 4
# 213 "../include/mico/os-math.h" 2
# 221 "../include/mico/os-math.h"
# 1 "../include/mico/lmath.h" 1
# 222 "../include/mico/os-math.h" 2

class OSMath {
    static MICO_Double _infinity;
    static MICO_LongDouble _long_infinity;
    static MICO_Double _notanumber;
    static MICO_LongDouble _long_notanumber;
public:
    static MICO_Double infinity (MICO_Boolean neg)
    {



        if (_infinity == 0) {
            sigset_t fpe;
            sigemptyset (&fpe);
            sigaddset (&fpe, 8);
            sigprocmask (0, &fpe, __null);

            _infinity = -1 / floor (0.1);
            sigprocmask (1, &fpe, __null);
        }
        return neg ? -_infinity : _infinity;

    }

    static MICO_Double nan ()
    {



        if (_notanumber == 0) {
            sigset_t fpe;
            sigemptyset (&fpe);
            sigaddset (&fpe, 8);
            sigprocmask (0, &fpe, __null);

            _notanumber = asin (2.0);
            sigprocmask (1, &fpe, __null);
        }
        return _notanumber;

    }

    static MICO_Boolean is_infinity (MICO_Double d)
    {

        return (sizeof (d) == sizeof (float) ? __isinff (d) : sizeof (d) == sizeof (double) ? __isinf (d) : __isinfl (d));





    }

    static MICO_Boolean is_nan (MICO_Double d)
    {

        return (sizeof (d) == sizeof (float) ? __isnanf (d) : sizeof (d) == sizeof (double) ? __isnan (d) : __isnanl (d));




    }

    static MICO_LongDouble infinityl (MICO_Boolean neg)
    {



        if (_long_infinity == 0) {
            sigset_t fpe;
            sigemptyset (&fpe);
            sigaddset (&fpe, 8);
            sigprocmask (0, &fpe, __null);

            _long_infinity = (long double)-1 / floor (0.1);
            sigprocmask (1, &fpe, __null);
        }
        return neg ? -_long_infinity : _long_infinity;

    }

    static MICO_LongDouble nanl ()
    {



        if (_long_notanumber == 0) {
            sigset_t fpe;
            sigemptyset (&fpe);
            sigaddset (&fpe, 8);
            sigprocmask (0, &fpe, __null);

            _long_notanumber = asinl (2.0);
            sigprocmask (1, &fpe, __null);
        }
        return _long_notanumber;

    }

    static MICO_Boolean is_infinityl (MICO_LongDouble d)
    {

        return isinfl (d);



    }

    static MICO_Boolean is_nanl (MICO_LongDouble d)
    {

        return isnanl (d);




    }
};
# 34 "any.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 35 "any.cc" 2

CORBA::Any::Any ()
{
    thetc = _tc_void;
    checker = new TypeCodeChecker ();
    ec = new MICO::CDREncoder ();
    dc = new MICO::CDRDecoder (ec->buffer(), 0, ec->byteorder(),
                               ec->converter(), 0);
    ec->valuestate (&value_estate, 0);
    dc->valuestate (&value_dstate, 0);
    extracted_value = 0;
}

CORBA::Any::Any (TypeCode_ptr tc, Buffer *b, Boolean release, int )
{
    thetc = CORBA::TypeCode::_duplicate (tc);
    checker = new TypeCodeChecker ();
    ec = new MICO::CDREncoder (b, 0, DefaultEndian, 0, 0, 0, 1);
    dc = new MICO::CDRDecoder (b, release, DefaultEndian, 0, 0, 0, 1);
    ec->valuestate (&value_estate, 0);
    dc->valuestate (&value_dstate, 0);
    extracted_value = 0;
}

CORBA::Any::Any (TypeCode_ptr tc, DataDecoder *_dc, DataEncoder *_ec)
{
    thetc = CORBA::TypeCode::_duplicate (tc);
    checker = new TypeCodeChecker ();
    ec = _ec;
    dc = _dc;

    extracted_value = 0;
}

CORBA::Any::Any (const Any &a)
{
    copy (a);
}

CORBA::Any::Any (TypeCode_ptr tc, void *value, Boolean release)
{
    thetc = _tc_void;
    checker = new TypeCodeChecker ();
    ec = new MICO::CDREncoder ();
    dc = new MICO::CDRDecoder (ec->buffer(), 0, ec->byteorder(),
                               ec->converter(), 0);
    ec->valuestate (&value_estate, 0);
    dc->valuestate (&value_dstate, 0);
    extracted_value = 0;

    replace (tc, value, release);
}

CORBA::Any::~Any ()
{
    free ();
}

inline CORBA::TypeCode_ptr
CORBA::Any::tc () const
{
    return thetc;
}

inline void
CORBA::Any::tc (TypeCode_ptr ntc)
{
    CORBA::release (thetc);
    thetc = ntc;
}

inline void
CORBA::Any::tc_if_changed (TypeCode_ptr ntc)
{
    if (thetc->equaltype (ntc)) {
        CORBA::release (ntc);
    } else {
        CORBA::release (thetc);
        thetc = ntc;
    }
}

CORBA::Any &
CORBA::Any::operator= (const Any &a)
{
    if (this != &a) {
        free ();
        copy (a);
    }
    return *this;
}

CORBA::Boolean
CORBA::Any::operator== (const Any &_a) const
{
    if (this == &_a)
        return 1;

    Any &me = (Any &)*this;
    Any &he = (Any &)_a;

    if (strcmp (me.ec->type(), he.ec->type()) ||
        strcmp (me.dc->type(), he.dc->type()))

        return equivalent (_a);

    if (!me.tc()->equaltype (he.tc()))
        return 0;

    return (me.length() == he.length() &&
            !memcmp (me.ec->buffer()->buffer(),
                     he.ec->buffer()->buffer(), me.length()));
}

CORBA::Boolean
CORBA::Any::equivalent (const Any &_a) const
{
    if (this == &_a)
        return 1;

    Any me (*this);
    Any he (_a);

    me.prepare_read ();
    he.prepare_read ();

    Boolean retval = me.compare_any (he);

    return retval;
}

void
CORBA::Any::free ()
{
    delete ec;
    delete dc;
    delete checker;
    CORBA::release (thetc);
    if (extracted_value)
        delete extracted_value;
}

void
CORBA::Any::copy (const Any &a)
{
    thetc = TypeCode::_duplicate (a.thetc);
    checker = new TypeCodeChecker ();
    value_estate = a.value_estate;
    value_dstate = a.value_dstate;
    ec = a.ec->clone ();
    dc = a.dc->clone (ec->buffer(), 0);
    ec->valuestate (&value_estate, 0);
    dc->valuestate (&value_dstate, 0);
    extracted_value = 0;
}

void
CORBA::Any::reset_extracted_value ()
{
    if (extracted_value) {
        delete extracted_value;
        extracted_value = 0;
    }
}

void
CORBA::Any::prepare_write ()
{
    if (checker->completed()) {
        value_estate.reset();
        ec->buffer()->reset();
        checker->restart (tc());
        reset_extracted_value();
    }
}

void
CORBA::Any::prepare_read ()
{
    if (checker->completed()) {
        value_dstate.reset();
        dc->buffer()->rseek_beg (0);
        checker->restart (tc());
    }
}

CORBA::Boolean
CORBA::Any::copy_any (Any &a, Boolean recurse)
{
    MapLL vidmap;
    return copy_any (a, vidmap, recurse);
}

CORBA::Boolean
CORBA::Any::copy_any (Any &a, MapLL &vidmap, Boolean recurse)
{
    TypeCode_ptr atc = a.checker->tc()->unalias();

    switch (atc->kind()) {
    case tk_null:
    case tk_void:
        return a.checker->basic (atc) && checker->basic (atc);

    case tk_short: {
        Short s;
        return (a >>= s) && insert (s);
    }
    case tk_long: {
        Long l;
        return (a >>= l) && insert (l);
    }
    case tk_longlong: {
        LongLong l;
        return (a >>= l) && insert (l);
    }
    case tk_ushort: {
        UShort us;
        return (a >>= us) && insert (us);
    }
    case tk_ulong: {
        ULong ul;
        return (a >>= ul) && insert (ul);
    }
    case tk_ulonglong: {
        ULongLong ul;
        return (a >>= ul) && insert (ul);
    }
    case tk_float: {
        Float f;
        return (a >>= f) && insert (f);
    }
    case tk_double: {
        Double d;
        return (a >>= d) && insert (d);
    }
    case tk_longdouble: {
        LongDouble d;
        return (a >>= d) && insert (d);
    }
    case tk_boolean: {
        Boolean b;
        return (a >>= to_boolean (b)) && insert (from_boolean (b));
    }
    case tk_char: {
        Char c;
        return (a >>= to_char (c)) && insert (from_char (c));
    }
    case tk_wchar: {
        WChar c;
        return (a >>= to_wchar (c)) && insert (from_wchar (c));
    }
    case tk_octet: {
        Octet o;
        return (a >>= to_octet (o)) && insert (from_octet (o));
    }
    case tk_any: {
        const Any* any;
        return ((a >>= any) && insert (*any));
    }
    case tk_objref: {
        Object_var obj;
        String_var name;
        return ((a >>= to_object (obj, name.out())) &&
                insert (from_object (obj, name)));
    }
    case tk_enum: {
        ULong en;
        return a.enum_get (en) && enum_put (en);
        break;
    }
    case tk_string: {
        const char *thestring;
        return ((a >>= to_string (thestring, atc->length())) &&
                insert (from_string (thestring, atc->length())));
    }
    case tk_wstring: {
        const wchar_t *thestring;
        return ((a >>= to_wstring (thestring, atc->length())) &&
                insert (from_wstring (thestring, atc->length())));
    }
    case tk_fixed: {
        UShort digits = atc->fixed_digits();
        Short scale = atc->fixed_scale();
        Fixed fixed (digits, scale);
        return ((a >>= to_fixed (fixed, digits, scale)) &&
                insert (from_fixed (fixed, digits, scale)));
    }
    case tk_alias:
        ((void) ((0) ? 0 : (__assert_fail ("0", "any.cc", 323, __PRETTY_FUNCTION__), 0)));

    case tk_TypeCode: {
        TypeCode_ptr t;
        return ((a >>= t) && insert (t));
    }
    case tk_Principal: {
        Principal_ptr p;
        return ((a >>= p) && insert (p));
    }
    default:
        break;
    }
    if (!recurse)
        return 0;

    switch (atc->kind()) {
    case tk_except: {
        String_var repoid;
        if (!a.except_get_begin (repoid) || !except_put_begin (repoid))
            return 0;
        CORBA::ULong n = atc->member_count();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!copy_any (a, vidmap))
                return 0;
        }
        return a.except_get_end() && except_put_end();
    }
    case tk_struct: {
        if (!a.struct_get_begin() || !struct_put_begin())
            return 0;
        CORBA::ULong n = atc->member_count();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!copy_any (a, vidmap))
                return 0;
        }
        return a.struct_get_end() && struct_put_end();
    }
    case tk_union: {
        if (!a.union_get_begin() || !union_put_begin())
            return 0;
        Any adisc;
        if (!a.any_get (adisc, 0))
            return 0;
        adisc.prepare_read ();
        if (!copy_any (adisc, vidmap, 0))
            return 0;
        Long i = atc->member_index (adisc);
        if (i >= 0) {
            if (!a.union_get_selection (i) || !union_put_selection (i))
                return 0;
            if (!copy_any (a, vidmap))
                return 0;
        }
        return a.union_get_end() && union_put_end();
    }
    case tk_sequence: {
        ULong seqlen;
        if (!a.seq_get_begin (seqlen) || !seq_put_begin (seqlen))
            return 0;





        CORBA::TypeCode_var ctc = atc->content_type ();
        if (ctc->unalias()->kind() == CORBA::tk_octet) {
          CORBA::Buffer * buf = a.dc->buffer ();
          if (buf->length() < seqlen) {
            return 0;
          }



          ec->put_octets (buf->data(), seqlen);
          buf->rseek_rel (seqlen);



          Boolean r;
          r = checker->seq_end (1);
          r &= a.checker->seq_end (1);
          r &= a.dc->seq_end ();
          ec->seq_end ();
          reset_extracted_value ();
          ((void) ((r) ? 0 : (__assert_fail ("r", "any.cc", 408, __PRETTY_FUNCTION__), 0)));
          return r;
        }





        for (CORBA::ULong i = 0; i < seqlen; ++i) {
          if (!copy_any (a, vidmap))
            return 0;
        }
        return a.seq_get_end() && seq_put_end();
    }
    case tk_array: {
        ULong arrlen = atc->length();
        if (!a.array_get_begin() || !array_put_begin())
            return 0;





        CORBA::TypeCode_var ctc = atc->content_type ();
        if (ctc->unalias()->kind() == CORBA::tk_octet) {
          CORBA::Buffer * buf = a.dc->buffer ();
          if (buf->length() < arrlen) {
            return 0;
          }



          ec->put_octets (buf->data(), arrlen);
          buf->rseek_rel (arrlen);



          Boolean r;
          r = checker->arr_end (1);
          r &= a.checker->arr_end (1);
          r &= a.dc->arr_end ();
          ec->arr_end ();
          reset_extracted_value ();
          ((void) ((r) ? 0 : (__assert_fail ("r", "any.cc", 451, __PRETTY_FUNCTION__), 0)));
          return r;
        }





        for (CORBA::ULong i = 0; i < arrlen; ++i) {
            if (!copy_any (a, vidmap))
                return 0;
        }
        return a.array_get_end() && array_put_end();
    }
    case tk_value: {
        Long vid1, vid2;
        Boolean is_ref;
        if (!a.value_get_begin (vid1, is_ref))
            return 0;
        if (is_ref) {
            vid2 = 0;
            if (vid1) {
                ((void) ((vidmap.count (vid1)) ? 0 : (__assert_fail ("vidmap.count (vid1)", "any.cc", 473, __PRETTY_FUNCTION__), 0)));
                vid2 = vidmap[vid1];
            }
            return value_put_ref (vid2);
        }
        if (!value_put_begin (vid2))
            return 0;
        vidmap[vid1] = vid2;
        CORBA::ULong n = atc->member_count_inherited();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!copy_any (a, vidmap))
                return 0;
        }
        return a.value_get_end (vid1, is_ref) && value_put_end(vid1);
    }
    case tk_value_box: {
        Long vid1, vid2;
        Boolean is_ref;
        if (!a.valuebox_get_begin (vid1, is_ref))
            return 0;
        if (is_ref) {
            vid2 = 0;
            if (vid1) {
                ((void) ((vidmap.count (vid1)) ? 0 : (__assert_fail ("vidmap.count (vid1)", "any.cc", 496, __PRETTY_FUNCTION__), 0)));
                vid2 = vidmap[vid1];
            }
            return valuebox_put_ref (vid2);
        }
        if (!valuebox_put_begin (vid2))
            return 0;
        vidmap[vid1] = vid2;
        if (!copy_any (a, vidmap))
            return 0;
        return a.valuebox_get_end (vid1, is_ref) && valuebox_put_end (vid1);
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "any.cc", 509, __PRETTY_FUNCTION__), 0)));
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::compare_any (Any &a)
{
    MapLL vidmap;
    return compare_any (a, vidmap);
}

CORBA::Boolean
CORBA::Any::compare_any (Any &a, MapLL &vidmap)
{
    TypeCode_ptr atc = a.checker->tc()->unalias();
    TypeCode_ptr mtc = checker->tc()->unalias();






    switch (atc->kind()) {
    case tk_null:
    case tk_void:
        return a.checker->basic (atc) && checker->basic (atc);

    case tk_short: {
        Short s1, s2;
        return (a >>= s1) && (*this >>= s2) && s1 == s2;
    }
    case tk_long: {
        Long l1, l2;
        return (a >>= l1) && (*this >>= l2) && l1 == l2;
    }
    case tk_longlong: {
        LongLong l1, l2;
        return (a >>= l1) && (*this >>= l2) && l1 == l2;
    }
    case tk_ushort: {
        UShort us1, us2;
        return (a >>= us1) && (*this >>= us2) && us1 == us2;
    }
    case tk_ulong: {
        ULong ul1, ul2;
        return (a >>= ul1) && (*this >>= ul2) && ul1 == ul2;
    }
    case tk_ulonglong: {
        ULongLong ul1, ul2;
        return (a >>= ul1) && (*this >>= ul2) && ul1 == ul2;
    }
    case tk_float: {
        Float f1, f2;
        return (a >>= f1) && (*this >>= f2) && f1 == f2;
    }
    case tk_double: {
        Double d1, d2;
        return (a >>= d1) && (*this >>= d2) && d1 == d2;
    }
    case tk_longdouble: {
        LongDouble d1, d2;
        return (a >>= d1) && (*this >>= d2) && d1 == d2;
    }
    case tk_boolean: {
        Boolean b1, b2;
        return (a >>= to_boolean (b1)) && (*this >>= to_boolean (b2))
            && b1 == b2;
    }
    case tk_char: {
        Char c1, c2;
        return (a >>= to_char (c1)) && (*this >>= to_char (c2)) && c1 == c2;
    }
    case tk_wchar: {
        WChar c1, c2;
        return (a >>= to_wchar (c1)) && (*this >>= to_wchar (c2)) && c1 == c2;
    }
    case tk_octet: {
        Octet o1, o2;
        return (a >>= to_octet (o1)) && (*this >>= to_octet (o2)) && o1 == o2;
    }
    case tk_any: {
        const Any *any1, *any2;
        return (a >>= any1) && (*this >>= any2) && *any1 == *any2;
    }
    case tk_objref: {
        Object_var objptr1, objptr2;
        return ((a >>= to_object (objptr1)) &&
                (*this >>= to_object (objptr2)) &&
                objptr1->_is_equivalent (objptr2));
    }
    case tk_enum: {
        ULong en1, en2;
        return a.enum_get (en1) && enum_get (en2) && en1 == en2;
        break;
    }
    case tk_string: {
        const char *str1, *str2;
        return ((a >>= to_string (str1, atc->length())) &&
                (*this >>= to_string (str2, mtc->length())) &&
                !strcmp (str1, str2));
    }
    case tk_wstring: {
        const wchar_t *str1, *str2;
        return ((a >>= to_wstring (str1, atc->length())) &&
                (*this >>= to_wstring (str2, mtc->length())) &&
                !xwcscmp (str1, str2));
    }
    case tk_fixed: {
        UShort digits = atc->fixed_digits();
        Short scale = atc->fixed_scale();
        Fixed val1 (digits, scale), val2 (digits, scale);
        return ((a >>= to_fixed (val1, digits, scale)) &&
                (*this >>= to_fixed (val2, digits, scale)) &&
                val1 == val2);
    }
    case tk_alias:
        ((void) ((0) ? 0 : (__assert_fail ("0", "any.cc", 626, __PRETTY_FUNCTION__), 0)));

    case tk_TypeCode: {
        TypeCode_ptr t1, t2;
        return ((a >>= t1) && (*this >>= t2) && t1->equal (t2));
    }
    case tk_Principal: {
        Principal_ptr p1, p2;
        return ((a >>= p1) && (*this >>= p2) && *p1 == *p2);
    }
    case tk_except: {
        String_var repoid1, repoid2;
        if (!a.except_get_begin (repoid1) ||
            !except_get_begin (repoid2) || strcmp (repoid1, repoid2))
            return 0;
        if (atc->member_count() != mtc->member_count())
            return 0;
        CORBA::ULong n = atc->member_count();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.except_get_end() && except_get_end();
    }
    case tk_struct: {
        if (!a.struct_get_begin() || !struct_get_begin())
            return 0;
        if (atc->member_count() != mtc->member_count())
            return 0;
        CORBA::ULong n = atc->member_count();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.struct_get_end() && struct_get_end();
    }
    case tk_union: {
        if (!a.union_get_begin() || !union_get_begin())
            return 0;
        Any adisc, mdisc;
        if (!a.any_get (adisc, 0))
            return 0;
        if (!any_get (mdisc, 0))
            return 0;
        if (!adisc.equivalent (mdisc))
            return 0;
        Long i = atc->member_index (adisc);
        if (i != mtc->member_index (mdisc))
            return 0;
        if (i >= 0) {
            if (!a.union_get_selection (i) || !union_get_selection (i))
                return 0;
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.union_get_end() && union_get_end();
    }
    case tk_sequence: {
        ULong seqlen1, seqlen2;
        if (!a.seq_get_begin (seqlen1) || !seq_get_begin (seqlen2))
            return 0;
        if (seqlen1 != seqlen2)
            return 0;
        for (CORBA::ULong i = 0; i < seqlen1; ++i) {
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.seq_get_end() && seq_get_end();
    }
    case tk_array: {
        ULong arrlen1 = atc->length();
        ULong arrlen2 = mtc->length();
        if (arrlen1 != arrlen2)
            return 0;
        if (!a.array_get_begin() || !array_get_begin())
            return 0;
        for (CORBA::ULong i = 0; i < arrlen1; ++i) {
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.array_get_end() && array_get_end();
    }
    case tk_value: {
        Long vid1, vid2;
        Boolean is_ref1, is_ref2;
        if (!a.value_get_begin (vid1, is_ref1))
            return 0;
        if (!value_get_begin (vid2, is_ref2))
            return 0;
        if (!!is_ref1 != !!is_ref2)
            return 0;
        if (is_ref1) {
            if (!!vid1 != !!vid2)
                return 0;
            if (vid1 == 0)
                return 1;
            ((void) ((vidmap.count (vid1)) ? 0 : (__assert_fail ("vidmap.count (vid1)", "any.cc", 722, __PRETTY_FUNCTION__), 0)));
            return (vidmap[vid1] == vid2);
        }
        vidmap[vid1] = vid2;
        CORBA::ULong n = atc->member_count_inherited();
        for (CORBA::ULong i = 0; i < n; ++i) {
            if (!compare_any (a, vidmap))
                return 0;
        }
        return a.value_get_end (vid1, is_ref1) &&
            value_get_end (vid2, is_ref2);
    }
    case tk_value_box: {
        Long vid1, vid2;
        Boolean is_ref1, is_ref2;
        if (!a.valuebox_get_begin (vid1, is_ref1))
            return 0;
        if (!valuebox_get_begin (vid2, is_ref2))
            return 0;
        if (!!is_ref1 != !!is_ref2)
            return 0;
        if (is_ref1) {
            if (!!vid1 != !!vid2)
                return 0;
            if (vid1 == 0)
                return 1;
            ((void) ((vidmap.count (vid1)) ? 0 : (__assert_fail ("vidmap.count (vid1)", "any.cc", 748, __PRETTY_FUNCTION__), 0)));
            return (vidmap[vid1] == vid2);
        }
        vidmap[vid1] = vid2;
        if (!compare_any (a, vidmap))
            return 0;
        return a.valuebox_get_end (vid1, is_ref1) &&
            valuebox_get_end (vid2, is_ref2);
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "any.cc", 758, __PRETTY_FUNCTION__), 0)));
    }
    return 0;
}

void
CORBA::Any::replace (TypeCode_ptr tc, void *value, Boolean release)
{
    reset ();
    set_type (tc);

    if (value) {
        Buffer b (value);
        Any a (tc, &b, 0, 0);

        prepare_write ();
        a.prepare_read ();
        CORBA::Boolean r = copy_any (a);
        ((void) ((r) ? 0 : (__assert_fail ("r", "any.cc", 776, __PRETTY_FUNCTION__), 0)));

        if (release)

            delete[] (CORBA::Octet *)value;
    }
}

void
CORBA::Any::replace (TypeCode_ptr tc)
{
    reset ();
    set_type (tc);

    switch (tc->unalias()->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:
        break;
    case CORBA::tk_char:
        *this <<= CORBA::Any::from_char (0);
        break;
    case CORBA::tk_wchar:
        *this <<= CORBA::Any::from_wchar (0);
        break;
    case CORBA::tk_boolean:
        *this <<= CORBA::Any::from_boolean (0);
        break;
    case CORBA::tk_octet:
        *this <<= CORBA::Any::from_octet (0);
        break;
    case CORBA::tk_short:
        *this <<= (CORBA::Short)0;
        break;
    case CORBA::tk_ushort:
        *this <<= (CORBA::UShort)0;
        break;
    case CORBA::tk_long:
        *this <<= (CORBA::Long)0;
        break;
    case CORBA::tk_longlong:
        *this <<= (CORBA::LongLong)0;
        break;
    case CORBA::tk_ulong:
        *this <<= (CORBA::ULong)0;
        break;
    case CORBA::tk_ulonglong:
        *this <<= (CORBA::ULongLong)0;
        break;
    case CORBA::tk_float:
        *this <<= (CORBA::Float)0;
        break;
    case CORBA::tk_double:
        *this <<= (CORBA::Double)0;
        break;
    case CORBA::tk_longdouble:
        *this <<= (CORBA::LongDouble)0;
        break;
    case CORBA::tk_any:
        *this <<= CORBA::Any();
        break;
    case CORBA::tk_TypeCode:
        *this <<= CORBA::_tc_void;
        break;
    case CORBA::tk_objref:
        *this <<= CORBA::Any::from_object (CORBA::Object::_nil(), "");
        break;
    case CORBA::tk_string:
        *this <<= "";
        break;
    case CORBA::tk_wstring:
        *this <<= L"";
        break;
    case CORBA::tk_enum:
        enum_put (0);
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "any.cc", 852, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::TypeCode_ptr
CORBA::Any::type () const
{
    return CORBA::TypeCode::_duplicate (tc());
}

void
CORBA::Any::set_type (TypeCode_ptr t)
{
    if (checker->level_count() == 0) {
        value_estate.reset();
        value_dstate.reset();
        ec->buffer()->reset ();
        tc (CORBA::TypeCode::_duplicate (t));
        checker->restart (tc());
        reset_extracted_value();

        switch (t->unalias()->kind()) {
        case CORBA::tk_void:
        case CORBA::tk_null:




            checker->finish();
            break;

        default:
            break;
        }
    }
}

void
CORBA::Any::type (TypeCode_ptr t)
{
    if (checker->level_count() != 0)
        mico_throw (CORBA::BAD_INV_ORDER());
    if (!t->equivalent (tc()))
        mico_throw (CORBA::BAD_TYPECODE());
    tc (CORBA::TypeCode::_duplicate (t));
    checker->restart (tc());

    switch (tc()->unalias()->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:




        checker->finish();
        break;

    default:
        break;
    }
}

void
CORBA::Any::reset ()
{
    value_estate.reset();
    value_dstate.reset();
    ec->buffer()->reset ();
    checker->restart ();
    reset_extracted_value();
}

void
CORBA::Any::rewind ()
{
    value_estate.reset();
    value_dstate.reset();
    dc->buffer()->rseek_beg (0);
    checker->restart ();
}

const void *
CORBA::Any::value () const
{
    if (ec->buffer()->wpos() > 0)
        return ec->buffer()->buffer();
    return 0;
}

CORBA::ULong
CORBA::Any::length () const
{
    return ec->buffer()->wpos();
}

void
CORBA::Any::encode (DataEncoder &e) const
{
    e.put_typecode (*tc());
    ((Any *)this)->marshal (e);
}

CORBA::Boolean
CORBA::Any::decode (DataDecoder &e)
{
    TypeCode_ptr t = TypeCode::create_basic_tc (tk_null);
    if (!e.get_typecode (*t) || !demarshal (t, e))
        return 0;
    CORBA::release (t);
    return 1;
}

CORBA::Boolean
CORBA::Any::marshal (DataEncoder &e)
{
    ((void) ((checker->completed()) ? 0 : (__assert_fail ("checker->completed()", "any.cc", 967, __PRETTY_FUNCTION__), 0)));
    Any a (tc(), new MICO::CDRDecoder,
           e.clone (e.buffer(), 0,
                    e.converter(), 0,
                    e.valuestate(), 0));


    a.value_estate.reset();
    a.checker->restart (a.tc());
    prepare_read ();
    return a.copy_any (*this);
}

CORBA::Boolean
CORBA::Any::demarshal (TypeCode_ptr t, DataDecoder &d)
{
    reset ();
    set_type (t);
    Any a (t, d.clone (d.buffer(), 0,
                       d.converter(), 0,
                       d.valuestate(), 0),
           new MICO::CDREncoder);


    a.value_dstate.reset();
    a.checker->restart (a.tc());
    prepare_write ();
    return copy_any (a);
}

CORBA::Boolean
CORBA::Any::from_static_any (const StaticAny &_sa, TypeCode_ptr t)
{
    StaticAny &sa = (StaticAny &)_sa;

    if (checker->completed()) {
        value_estate.reset();
        ec->buffer()->reset();
        tc_if_changed (CORBA::TypeCode::_duplicate (t));
    } else if (!checker->basic (t)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    sa.marshal (*ec);
    return 1;
}

CORBA::Boolean
CORBA::Any::from_static_any (const StaticAny &_sa)
{
    StaticAny &sa = (StaticAny &)_sa;

    CORBA::TypeCode_ptr t = sa.typecode();
    if (CORBA::is_nil (t))
        t = tc();

    if (checker->completed()) {
        value_estate.reset();
        ec->buffer()->reset();
        tc_if_changed (CORBA::TypeCode::_duplicate (t));
    } else if (!checker->basic (t)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    sa.marshal (*ec);
    return 1;
}

CORBA::Boolean
CORBA::Any::to_static_any (StaticAny &sa, CORBA::TypeCode_ptr t) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->basic (t) || !sa.demarshal (*me.dc)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::to_static_any (StaticAny &sa) const
{
    CORBA::TypeCode_ptr t = sa.typecode();
    if (CORBA::is_nil (t))
        t = tc();
    return to_static_any (sa, t);
}

CORBA::Boolean
CORBA::Any::to_static_any (StaticTypeInfo *ti, CORBA::TypeCode_ptr t,
                           void *&value) const
{
    Any &me = (Any &)*this;

    if (!me.extracted_value || !me.checker->completed()) {
        me.reset_extracted_value();
        me.extracted_value = new StaticAny (ti);
        if (!to_static_any (*me.extracted_value, t)) {
            me.reset_extracted_value();
            return 0;
        }
        value = me.extracted_value->value();
        return 1;
    }
    me.prepare_read ();
    if (!me.checker->basic (t)) {
        me.rewind ();
        return 0;
    }
    if (me.extracted_value->type() != ti) {
        return 0;
    }
    value = me.extracted_value->value();
    return 1;
}

CORBA::Boolean
CORBA::Any::to_static_any (StaticTypeInfo *ti, void *&value) const
{
    CORBA::TypeCode_ptr t = ti->typecode();
    if (CORBA::is_nil (t))
        t = tc();
    return to_static_any (ti, t, value);
}

CORBA::Boolean
CORBA::Any::insert (Short s)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_short);
    } else if (!checker->basic (_tc_short)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_short (s);
    return 1;
}

void
CORBA::Any::operator<<= (Short s)
{
    insert (s);
}

CORBA::Boolean
CORBA::Any::insert (Long l)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_long);
    } else if (!checker->basic (_tc_long)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_long (l);
    return 1;
}

void
CORBA::Any::operator<<= (Long l)
{
    insert (l);
}

CORBA::Boolean
CORBA::Any::insert (LongLong l)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_longlong);
    } else if (!checker->basic (_tc_longlong)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_longlong (l);
    return 1;
}

void
CORBA::Any::operator<<= (LongLong l)
{
    insert (l);
}

CORBA::Boolean
CORBA::Any::insert (UShort us)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_ushort);
    } else if (!checker->basic (_tc_ushort)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_ushort (us);
    return 1;
}

void
CORBA::Any::operator<<= (UShort us)
{
    insert (us);
}

CORBA::Boolean
CORBA::Any::insert (ULong ul)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_ulong);
    } else if (!checker->basic (_tc_ulong)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_ulong (ul);
    return 1;
}

void
CORBA::Any::operator<<= (ULong ul)
{
    insert (ul);
}

CORBA::Boolean
CORBA::Any::insert (ULongLong ul)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_ulonglong);
    } else if (!checker->basic (_tc_ulonglong)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_ulonglong (ul);
    return 1;
}

void
CORBA::Any::operator<<= (ULongLong ul)
{
    insert (ul);
}

CORBA::Boolean
CORBA::Any::insert (Float f)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_float);
    } else if (!checker->basic (_tc_float)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_float (f);
    return 1;
}

void
CORBA::Any::operator<<= (Float f)
{
    insert (f);
}

CORBA::Boolean
CORBA::Any::insert (Double d)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_double);
    } else if (!checker->basic (_tc_double)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_double (d);
    return 1;
}

void
CORBA::Any::operator<<= (Double d)
{
    insert (d);
}

CORBA::Boolean
CORBA::Any::insert (LongDouble d)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_longdouble);
    } else if (!checker->basic (_tc_longdouble)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_longdouble (d);
    return 1;
}

void
CORBA::Any::operator<<= (LongDouble d)
{
    insert (d);
}

CORBA::Boolean
CORBA::Any::insert (const Any &a)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_any);
    } else if (!checker->basic (_tc_any)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_any (a);
    return 1;
}

void
CORBA::Any::operator<<= (const Any &a)
{
    insert (a);
}

CORBA::Boolean
CORBA::Any::insert (Any *a)
{
    CORBA::Boolean _ret = insert (*a);
    delete a;
    return _ret;
}

void
CORBA::Any::operator<<= (Any *a)
{
    insert (a);
}

CORBA::Boolean
CORBA::Any::insert (const Exception &e)
{
    e._encode_any (*this);
    return 1;
}

void
CORBA::Any::operator<<= (const Exception &e)
{
    insert (e);
}

CORBA::Boolean
CORBA::Any::insert (Exception *e)
{
    CORBA::Boolean _ret = insert (*e);
    delete e;
    return _ret;
}

void
CORBA::Any::operator<<= (Exception *e)
{
    insert (e);
}

CORBA::Boolean
CORBA::Any::insert (const char *s)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_string);
    } else if (!checker->basic (_tc_string)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_string (s ? s : "");
    return 1;
}

void
CORBA::Any::operator<<= (const char *s)
{
    insert (s);
}

CORBA::Boolean
CORBA::Any::insert (const wchar_t *s)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_wstring);
    } else if (!checker->basic (_tc_wstring)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_wstring (s ? s : L"");
    return 1;
}

void
CORBA::Any::operator<<= (const wchar_t *s)
{
    insert (s);
}

CORBA::Boolean
CORBA::Any::insert (from_boolean b)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_boolean);
    } else if (!checker->basic (_tc_boolean)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_boolean (b.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_boolean b)
{
    insert (b);
}

CORBA::Boolean
CORBA::Any::insert (from_octet o)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_octet);
    } else if (!checker->basic (_tc_octet)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_octet (o.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_octet o)
{
    insert (o);
}

CORBA::Boolean
CORBA::Any::insert (from_char c)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_char);
    } else if (!checker->basic (_tc_char)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_char (c.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_char c)
{
    insert (c);
}

CORBA::Boolean
CORBA::Any::insert (from_wchar c)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_wchar);
    } else if (!checker->basic (_tc_wchar)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_wchar (c.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_wchar c)
{
    insert (c);
}

CORBA::Boolean
CORBA::Any::insert (from_string s)
{
    if (s.bound > 0 && s.val && strlen (s.val) > s.bound)
        return 0;
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (TypeCode::create_string_tc (s.bound));
    } else {
        TypeCode_var tmp = TypeCode::create_string_tc (s.bound);
        if (!checker->basic (tmp)) {
            reset ();
            return 0;
        }
    }
    reset_extracted_value();
    ec->put_string (s.val ? s.val : "");
    if (s.nocopy)
        CORBA::string_free (s.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_string s)
{
    insert (s);
}

CORBA::Boolean
CORBA::Any::insert (from_wstring s)
{
    if (s.bound > 0 && s.val && xwcslen (s.val) > s.bound)
        return 0;
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (TypeCode::create_wstring_tc (s.bound));
    } else {
        TypeCode_var tmp = TypeCode::create_wstring_tc (s.bound);
        if (!checker->basic (tmp)) {
            reset ();
            return 0;
        }
    }
    reset_extracted_value();
    ec->put_wstring (s.val ? s.val : L"");
    if (s.nocopy)
        CORBA::wstring_free (s.val);
    return 1;
}

void
CORBA::Any::operator<<= (from_wstring s)
{
    insert (s);
}

CORBA::Boolean
CORBA::Any::insert (from_fixed f)
{
    Fixed::FixedValue_var value = f.fixed.to_digits();

    if ((CORBA::ULong)f.digits+1 != value->length())
        return 0;
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (TypeCode::create_fixed_tc (f.digits, f.scale));
    } else {
        TypeCode_var tmp = TypeCode::create_fixed_tc (f.digits, f.scale);
        if (!checker->basic (tmp)) {
            reset ();
            return 0;
        }
    }
    reset_extracted_value();
    ec->put_fixed (value.in(), f.digits, f.scale);
    return 1;
}

void
CORBA::Any::operator<<= (from_fixed f)
{
    insert (f);
}

CORBA::Boolean
CORBA::Any::insert (from_object o)
{
    IOR *ior;
    const char *repoid;
    if (CORBA::is_nil (o.val)) {
        ior = new IOR;
        repoid = "";
    } else {
        ior = o.val->_ior();
        if (!ior) {

            reset ();
            return 0;
        }
        repoid = ior->objid();
    }
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (TypeCode::create_interface_tc (repoid, o.name));
    } else if (checker->tc()->kind() != tk_objref ||
               !checker->basic (checker->tc())) {

        if (CORBA::is_nil (o.val))
            delete ior;
        reset ();
        return 0;
    }

    reset_extracted_value();
    ec->put_ior (*ior);
    if (CORBA::is_nil (o.val))
        delete ior;
    return 1;
}

void
CORBA::Any::operator<<= (from_object o)
{
    insert (o);
}

CORBA::Boolean
CORBA::Any::insert (Object_ptr t)
{
    return insert (from_object (t, ""));
}

void
CORBA::Any::operator<<= (Object_ptr t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (Object_ptr *t)
{
    CORBA::Boolean _ret = insert (*t);
    CORBA::release (*t);
    return _ret;
}

void
CORBA::Any::operator<<= (Object_ptr *t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (TypeCode_ptr t)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_TypeCode);
    } else if (!checker->basic (_tc_TypeCode)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_typecode (*t);
    return 1;
}

void
CORBA::Any::operator<<= (TypeCode_ptr t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (TypeCode_ptr *t)
{
    CORBA::Boolean _ret = insert (*t);
    CORBA::release (*t);
    return _ret;
}

void
CORBA::Any::operator<<= (TypeCode_ptr *t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (Context_ptr ctx)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_Context);
    } else if (!checker->basic (_tc_Context)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_context (*ctx);
    return 1;
}

void
CORBA::Any::operator<<= (Context_ptr t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (Context_ptr *t)
{
    CORBA::Boolean _ret = insert (*t);
    CORBA::release (*t);
    return _ret;
}

void
CORBA::Any::operator<<= (Context_ptr *t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (Principal_ptr pr)
{
    if (checker->completed()) {
        ec->buffer()->reset();
        tc_if_changed (_tc_Principal);
    } else if (!checker->basic (_tc_Principal)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->put_principal (*pr);
    return 1;
}

void
CORBA::Any::operator<<= (Principal_ptr t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::insert (Principal_ptr *t)
{
    CORBA::Boolean _ret = insert (*t);
    CORBA::release (*t);
    return _ret;
}

void
CORBA::Any::operator<<= (Principal_ptr *t)
{
    insert (t);
}

CORBA::Boolean
CORBA::Any::get_short (Short &s)
{
    return (checker->basic (_tc_short) && dc->get_short (s));
}

CORBA::Boolean
CORBA::Any::operator>>= (Short &s) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_short (s)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_long (Long &l)
{
    if (checker->basic (_tc_long)) {
        return dc->get_long (l);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (Long &l) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_long (l)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_longlong (LongLong &l)
{
    if (checker->basic (_tc_longlong)) {
        return dc->get_longlong (l);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (LongLong &l) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_longlong (l)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_ushort (UShort &us)
{
    return (checker->basic (_tc_ushort) && dc->get_ushort (us));
}

CORBA::Boolean
CORBA::Any::operator>>= (UShort &us) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_ushort (us)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_ulong (ULong &ul)
{
    if (checker->basic (_tc_ulong)) {
        return dc->get_ulong (ul);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (ULong &ul) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_ulong (ul)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_ulonglong (ULongLong &ul)
{
    if (checker->basic (_tc_ulonglong)) {
        return dc->get_ulonglong (ul);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (ULongLong &ul) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_ulonglong (ul)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_float (Float &f)
{
    if (checker->basic (_tc_float)) {
        return dc->get_float (f);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (Float &f) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_float (f)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_double (Double &d)
{
    if (checker->basic (_tc_double)) {
        return dc->get_double (d);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (Double &d) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_double (d)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::get_longdouble (LongDouble &d)
{
    if (checker->basic (_tc_longdouble)) {
        return dc->get_longdouble (d);
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (LongDouble &d) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.get_longdouble (d)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (const Any *&a) const
{
    return to_static_any (_stc_any, (void *&)a);
}

CORBA::Boolean
CORBA::Any::operator>>= (const char * &s) const
{
    char **p;
    if (to_static_any (_stc_string, (void *&)p)) {
        s = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (const wchar_t * &s) const
{
    wchar_t **p;
    if (to_static_any (_stc_wstring, (void *&)p)) {
        s = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_boolean b) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->basic (_tc_boolean) || !me.dc->get_boolean (b.ref)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_octet o) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->basic (_tc_octet) || !me.dc->get_octet (o.ref)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_char c) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->basic (_tc_char) || !me.dc->get_char (c.ref)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_wchar c) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->basic (_tc_wchar) || !me.dc->get_wchar (c.ref)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_string s) const
{
    char **p;
    TypeCode_var tmp = TypeCode::create_string_tc (s.bound);
    if (to_static_any (_stc_string, tmp, (void *&)p)) {
        s.ref = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_wstring s) const
{
    wchar_t **p;
    TypeCode_var tmp = TypeCode::create_wstring_tc (s.bound);
    if (to_static_any (_stc_wstring, tmp, (void *&)p)) {
        s.ref = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_fixed f) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    TypeCode_var tmp = TypeCode::create_fixed_tc (f.digits, f.scale);
    FixedBase::FixedValue val;
    if (!me.checker->basic (tmp) ||
        !me.dc->get_fixed (val, f.digits, f.scale)) {
        me.rewind ();
        return 0;
    }
    f.fixed.from_digits (val);
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_object o) const
{
    Any &me = (Any &)*this;

    me.prepare_read();
    if (me.checker->tc()->kind () != tk_objref) {
        me.rewind ();
        return 0;
    }

    Object_ptr *p;
    if (to_static_any (_stc_Object, checker->tc(), (void *&)p)) {
        o.ref = CORBA::Object::_duplicate (*p);
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (to_abstract_base o) const
{
    Any &me = (Any &)*this;

    me.prepare_read();
    if (me.checker->tc()->kind () != tk_abstract_interface) {
        me.rewind ();
        return 0;
    }

    AbstractBase_ptr *p;
    if (!to_static_any (_stc_AbstractBase, checker->tc(), (void *&)p)) {
        o.ref = CORBA::AbstractBase::_duplicate (*p);
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (Object_ptr &t) const
{
    CORBA::Object_var tv;
    if (!(*this >>= to_object (tv))) {
        return 0;
    }

    t = tv.in();
    return 1;
}

CORBA::Boolean
CORBA::Any::operator>>= (TypeCode_ptr &t) const
{
    TypeCode_ptr *p;
    if (to_static_any (_stc_TypeCode, (void *&)p)) {
        t = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (Context_ptr &ctx) const
{
    Context_ptr *p;
    if (to_static_any (_stc_Context, (void *&)p)) {
        ctx = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::operator>>= (Principal_ptr &pr) const
{
    Principal_ptr *p;
    if (to_static_any (_stc_Principal, (void *&)p)) {
        pr = *p;
        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Any::struct_put_begin ()
{
    prepare_write ();
    if (!checker->struct_begin()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->struct_begin ();
    return 1;
}

CORBA::Boolean
CORBA::Any::struct_put_end ()
{
    if (!checker->struct_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->struct_end ();
    return 1;
}

CORBA::Boolean
CORBA::Any::union_put_begin ()
{
    prepare_write ();
    if (!checker->union_begin()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->union_begin ();
    return 1;
}

CORBA::Boolean
CORBA::Any::union_put_selection (Long idx)
{
    if (!checker->union_selection (idx)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    return 1;
}

CORBA::Boolean
CORBA::Any::union_put_end ()
{
    if (!checker->union_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->union_end();
    return 1;
}

CORBA::Boolean
CORBA::Any::enum_put (ULong val)
{
    prepare_write ();
    if (!checker->enumeration (val)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->enumeration (val);
    return 1;
}

CORBA::Boolean
CORBA::Any::any_put (Any &a, Boolean recurse)
{
    prepare_write ();
    a.prepare_read ();
    reset_extracted_value();
    if (!copy_any (a, recurse)) {
        reset ();
        a.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::seq_put_begin (ULong len)
{
    prepare_write ();
    if (!checker->seq_begin (len)) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->seq_begin (len);
    return 1;
}

CORBA::Boolean
CORBA::Any::seq_put_end ()
{
    if (!checker->seq_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->seq_end();
    return 1;
}

CORBA::Boolean
CORBA::Any::array_put_begin ()
{
    prepare_write ();
    if (!checker->arr_begin()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->arr_begin ();
    return 1;
}

CORBA::Boolean
CORBA::Any::array_put_end ()
{
    if (!checker->arr_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->arr_end();
    return 1;
}

CORBA::Boolean
CORBA::Any::except_put_begin (const char *repoid)
{
    prepare_write ();
    if (!checker->except_begin()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->except_begin (repoid);
    return 1;
}

CORBA::Boolean
CORBA::Any::except_put_end ()
{
    if (!checker->except_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->except_end();
    return 1;
}

CORBA::Boolean
CORBA::Any::value_put_begin (Long &value_id)
{
    prepare_write ();

    CORBA::TypeCode_var vtc = CORBA::TypeCode::_duplicate (checker->tc());

    if (!checker->value_begin()) {
        reset ();
        return 0;
    }


    Boolean chunked = !!(vtc->type_modifier() & VM_TRUNCATABLE);


    vector<string> repoids;
    repoids.push_back (vtc->id());
    while (vtc->type_modifier() & VM_TRUNCATABLE) {
        vtc = vtc->concrete_base_type();
        ((void) ((!CORBA::is_nil (vtc)) ? 0 : (__assert_fail ("!CORBA::is_nil (vtc)", "any.cc", 2309, __PRETTY_FUNCTION__), 0)));
        repoids.push_back (vtc->id());
    }

    reset_extracted_value();
    ec->value_begin ("", repoids, chunked, value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::value_put_end (Long value_id)
{
    if (!checker->value_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->value_end (value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::value_put_ref (Long value_id)
{
    checker->basic (checker->tc());
    reset_extracted_value();
    ec->value_ref (value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::valuebox_put_begin (Long &value_id)
{
    prepare_write ();

    CORBA::TypeCode_var vtc = CORBA::TypeCode::_duplicate (checker->tc());

    if (!checker->valuebox_begin()) {
        reset ();
        return 0;
    }

    vector<string> repoids;
    repoids.push_back (vtc->id());

    reset_extracted_value();
    ec->value_begin ("", repoids, 0, value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::valuebox_put_end (Long value_id)
{
    if (!checker->valuebox_end()) {
        reset ();
        return 0;
    }
    reset_extracted_value();
    ec->value_end (value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::valuebox_put_ref (Long value_id)
{
    checker->basic (checker->tc());
    reset_extracted_value();
    ec->value_ref (value_id);
    return 1;
}

CORBA::Boolean
CORBA::Any::struct_get_begin () const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->struct_begin() || !me.dc->struct_begin ()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::struct_get_end () const
{
    Any &me = (Any &)*this;

    if (!me.checker->struct_end() || !me.dc->struct_end()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::union_get_begin () const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->union_begin() || !me.dc->union_begin()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::union_get_selection (Long idx) const
{
    Any &me = (Any &)*this;

    if (!me.checker->union_selection (idx)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::union_get_end () const
{
    Any &me = (Any &)*this;

    if (!me.checker->union_end() || !me.dc->union_end()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::enum_get (ULong &val) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.dc->enumeration (val) || !me.checker->enumeration (val)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::any_get (Any &a, Boolean recurse) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    a.set_type (checker->tc());
    a.prepare_write ();
    if (!a.copy_any (me, recurse)) {
        me.rewind ();
        a.reset ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::seq_get_begin (ULong &len) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.dc->seq_begin (len) || !me.checker->seq_begin (len)) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::seq_get_end () const
{
    Any &me = (Any &)*this;

    if (!me.checker->seq_end() || !me.dc->seq_end()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::array_get_begin () const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    if (!me.checker->arr_begin() || !me.dc->arr_begin()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::array_get_end () const
{
    Any &me = (Any &)*this;

    if (!me.checker->arr_end() || !me.dc->arr_end()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::except_get_begin (String_out repoid) const
{
    Any &me = (Any &)*this;

    me.prepare_read ();
    string s;
    if (!me.checker->except_begin() || !me.dc->except_begin (s)) {
        me.rewind ();
        return 0;
    }
    repoid = CORBA::string_dup (s.c_str());
    return 1;
}

CORBA::Boolean
CORBA::Any::except_get_end () const
{
    Any &me = (Any &)*this;

    if (!me.checker->except_end() || !me.dc->except_end()) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::value_get_begin (Long &value_id, Boolean &is_ref) const
{
    Any &me = (Any &)*this;
    me.prepare_read ();

    CORBA::TypeCode_var vtc = CORBA::TypeCode::_duplicate (checker->tc());

    string url;
    vector<string> repoids;

    if (!me.checker->value_begin() ||
        !me.dc->value_begin (url, repoids, value_id, is_ref)) {
        me.rewind ();
        return 0;
    }
    if (is_ref) {
        me.checker->basic (me.checker->tc());
        return 1;
    }


    string myrepoid = vtc->id();
    for (mico_vec_size_type i = 0; i < repoids.size(); ++i) {
        if (repoids[i] == myrepoid) {
            return 1;
        }
    }
    me.rewind ();
    return 0;
}

CORBA::Boolean
CORBA::Any::value_get_end (Long value_id, Boolean is_ref) const
{
    Any &me = (Any &)*this;

    if (!me.checker->value_end() ||
        (!is_ref && !me.dc->value_end (value_id))) {
        me.rewind ();
        return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::Any::valuebox_get_begin (Long &value_id, Boolean &is_ref) const
{
    Any &me = (Any &)*this;
    me.prepare_read ();

    CORBA::TypeCode_var vtc = CORBA::TypeCode::_duplicate (checker->tc());

    string url;
    vector<string> repoids;

    if (!me.checker->valuebox_begin() ||
        !me.dc->value_begin (url, repoids, value_id, is_ref)) {
        me.rewind ();
        return 0;
    }
    if (is_ref) {
        me.checker->basic (me.checker->tc());
        return 1;
    }


    string myrepoid = vtc->id();
    for (mico_vec_size_type i = 0; i < repoids.size(); ++i) {
        if (repoids[i] == myrepoid) {
            return 1;
        }
    }
    me.rewind ();
    return 0;
}

CORBA::Boolean
CORBA::Any::valuebox_get_end (Long value_id, Boolean is_ref) const
{
    Any &me = (Any &)*this;

    if (!me.checker->valuebox_end() ||
        (!is_ref && !me.dc->value_end (value_id))) {
        me.rewind ();
        return 0;
    }
    return 1;
}


class ConstValue {
    CORBA::ULongLong _uv;
    CORBA::LongLong _sv;
    CORBA::LongDouble _fv;
    enum Kind { SignedValue, UnsignedValue, FloatValue } _kind;
public:
    ConstValue ()
    {
        _uv = 0;
        _sv = 0;
        _fv = 0;
        _kind = SignedValue;
    }
    void from_signed (CORBA::LongLong v)
    {
        _sv = v;
        _kind = SignedValue;
    }
    void from_unsigned (CORBA::ULongLong v)
    {
        _uv = v;
        _kind = UnsignedValue;
    }
    void from_float (CORBA::LongDouble v)
    {
        _fv = v;
        _kind = FloatValue;
    }
    CORBA::LongLong to_signed () const
    {
        switch (_kind) {
        case SignedValue:
            return _sv;
        case UnsignedValue:
            return _uv;
        case FloatValue:
            return (CORBA::LongLong)_fv;
        }
        return 0;
    }
    CORBA::ULongLong to_unsigned () const
    {
        switch (_kind) {
        case SignedValue:
            return _sv;
        case UnsignedValue:
            return _uv;
        case FloatValue:
            return (CORBA::ULongLong)_fv;
        }
        return 0;
    }
    CORBA::LongDouble to_float () const
    {
        switch (_kind) {
        case SignedValue:
            return _sv;
        case UnsignedValue:



            return _uv;

        case FloatValue:
            return _fv;
        }
        return 0;
    }
    CORBA::Boolean signed_range (CORBA::LongLong lower,
                                 CORBA::LongLong upper) const
    {
        switch (_kind) {
        case SignedValue:
            return lower <= _sv && _sv <= upper;
        case UnsignedValue:
            return _uv <= upper;
        case FloatValue:
            return lower <= _fv && _fv <= upper;
        }
        return 0;
    }
    CORBA::Boolean unsigned_range (CORBA::ULongLong upper) const
    {
        switch (_kind) {
        case SignedValue:
            return 0 <= _sv && _sv <= upper;
        case UnsignedValue:
            return _uv <= upper;
        case FloatValue:



            return 0 <= _fv && _fv <= upper;

        }
        return 0;
    }
    CORBA::Boolean float_range (CORBA::LongDouble lower,
                                CORBA::LongDouble upper) const
    {
        switch (_kind) {
        case SignedValue:
            return lower <= _sv && _sv <= upper;
        case UnsignedValue:



            return lower <= _uv && _uv <= upper;

        case FloatValue:
            return lower <= _fv && _fv <= upper;
        }
        return 0;
    }
};

CORBA::Boolean
CORBA::Any::coerce (CORBA::Any &dst) const
{
    const CORBA::Any &src = *this;
    CORBA::TypeCode_var stype = src.type();
    stype = CORBA::TypeCode::_duplicate (stype->unalias());
    CORBA::TypeCode_var dtype = dst.type();
    dtype = CORBA::TypeCode::_duplicate (dtype->unalias());

    if (stype->equal (dtype)) {
        dst = *this;
        return 1;
    }

    ConstValue cv;

    switch (stype->kind()) {
    case CORBA::tk_char: {
        if (dtype->kind() != CORBA::tk_wchar)
            return 0;
        CORBA::Char c;
        src >>= CORBA::Any::to_char (c);
        dst <<= CORBA::Any::from_wchar ((CORBA::WChar)(c & 0xff));
        return 1;
    }
    case CORBA::tk_wchar: {
        if (dtype->kind() != CORBA::tk_char)
            return 0;
        CORBA::WChar c;
        src >>= CORBA::Any::to_wchar (c);
        if (c & ~0xff)
            return 0;
        dst <<= CORBA::Any::from_char ((CORBA::Char)c);
        return 1;
    }
    case CORBA::tk_string: {
        if (dtype->kind() == CORBA::tk_string) {

          const char *s;
          src >>= CORBA::Any::to_string (s, stype->length());
          if (dtype->length() != 0 && dtype->length() < strlen (s))
            return 0;
          dst <<= CORBA::Any::from_string (s, dtype->length());
          return 1;
        }
        if (dtype->kind() != CORBA::tk_wstring)
            return 0;
        const char *s;
        src >>= CORBA::Any::to_string (s, 0);
        CORBA::WString_var w = CORBA::wstring_alloc (strlen (s));
        for (size_t i = 0; i < strlen (s); i++)
            w[(CORBA::ULong)i] = s[i] & 0xff;
        w[(CORBA::ULong)strlen(s)] = 0;

        dst <<= w.in();
        return 1;
    }
    case CORBA::tk_wstring: {
        if (dtype->kind() == CORBA::tk_wstring) {

          const wchar_t *w;
          src >>= CORBA::Any::to_wstring (w, stype->length());
          if (dtype->length() != 0 && dtype->length() < xwcslen (w))
            return 0;
          dst <<= CORBA::Any::from_wstring (w, dtype->length());
          return 1;
        }
        if (dtype->kind() != CORBA::tk_string)
            return 0;
        const wchar_t *w;
        src >>= CORBA::Any::to_wstring (w, 0);
        CORBA::String_var s = CORBA::string_alloc (xwcslen (w));
        for (size_t i = 0; i < xwcslen (w); i++) {
            if (w[i] & ~0xff)
                return 0;
            s[(CORBA::ULong)i] = w[i] & 0xff;
        }
        s[(CORBA::ULong)xwcslen(w)] = 0;
        dst <<= CORBA::Any::from_string (s, 0);
        return 1;
    }
    case CORBA::tk_short: {
        CORBA::Short v;
        src >>= v;
        cv.from_signed (v);
        break;
    }
    case CORBA::tk_ushort: {
        CORBA::Short v;
        src >>= v;
        cv.from_unsigned (v);
        break;
    }
    case CORBA::tk_long: {
        CORBA::Long v;
        src >>= v;
        cv.from_signed (v);
        break;
    }
    case CORBA::tk_ulong: {
        CORBA::ULong v;
        src >>= v;
        cv.from_unsigned (v);
        break;
    }
    case CORBA::tk_longlong: {
        CORBA::LongLong v;
        src >>= v;
        cv.from_signed (v);
        break;
    }
    case CORBA::tk_ulonglong: {
        CORBA::ULongLong v;
        src >>= v;
        cv.from_unsigned (v);
        break;
    }
    case CORBA::tk_float: {
        CORBA::Float v;
        src >>= v;
        cv.from_float (v);
        break;
    }
    case CORBA::tk_double: {
        CORBA::Double v;
        src >>= v;
        cv.from_float (v);
        break;
    }
    case CORBA::tk_longdouble: {
        CORBA::LongDouble v;
        src >>= v;
        cv.from_float (v);
        break;
    }
    case CORBA::tk_fixed: {
        FixedBase f (stype->fixed_digits(), stype->fixed_scale());
        src >>= CORBA::Any::to_fixed (f, stype->fixed_digits(),
                                      stype->fixed_scale());
        cv.from_float (f);
        break;
    }
    default:
        return 0;
    }

    switch (dtype->kind()) {
    case CORBA::tk_short: {
        CORBA::LongLong upper = 0x7fffl;
        CORBA::LongLong lower = - upper - 1;
        if (!cv.signed_range (lower, upper))
            return 0;
        dst <<= (CORBA::Short)cv.to_signed();
        break;
    }
    case CORBA::tk_ushort: {
        CORBA::ULongLong upper = 0xfffful;
        if (!cv.unsigned_range (upper))
            return 0;
        dst <<= (CORBA::UShort)cv.to_unsigned();
        break;
    }
    case CORBA::tk_long: {
        CORBA::LongLong upper = 0x7fffffffl;
        CORBA::LongLong lower = - upper - 1;
        if (!cv.signed_range (lower, upper))
            return 0;
        dst <<= (CORBA::Long)cv.to_signed();
        break;
    }
    case CORBA::tk_ulong: {
        CORBA::ULongLong upper = 0xfffffffful;
        if (!cv.unsigned_range (upper))
            return 0;
        dst <<= (CORBA::ULong)cv.to_unsigned();
        break;
    }
    case CORBA::tk_longlong: {
        CORBA::LongLong upper = ~(((CORBA::LongLong)1) << 63);
        CORBA::LongLong lower = - upper - 1;
        if (!cv.signed_range (lower, upper))
            return 0;
        dst <<= (CORBA::LongLong)cv.to_signed();
        break;
    }
    case CORBA::tk_ulonglong: {
        CORBA::ULongLong upper = ~((CORBA::ULongLong)0);
        if (!cv.unsigned_range (upper))
            return 0;
        dst <<= (CORBA::ULongLong)cv.to_unsigned();
        break;
    }
    case CORBA::tk_float: {
        CORBA::LongDouble bound = ldexpl (1.999, 128);
        if (!cv.float_range (-bound, bound))
            return 0;
        dst <<= (CORBA::Float)cv.to_float();
        break;
    }
    case CORBA::tk_double: {
        CORBA::LongDouble bound = ldexpl (1.999, 1024);
        if (!cv.float_range (-bound, bound))
            return 0;
        dst <<= (CORBA::Double)cv.to_float();
        break;
    }
    case CORBA::tk_longdouble: {

        dst <<= (CORBA::LongDouble)cv.to_float();
        break;
    }
    case CORBA::tk_fixed: {

        FixedBase f (dtype->fixed_digits(), dtype->fixed_scale());
        f = FixedBase ((CORBA::LongDouble)cv.to_float());
        dst <<= CORBA::Any::from_fixed (f, dtype->fixed_digits(),
                                        dtype->fixed_scale());
        break;
    }
    default:
        return 0;
    }
    return 1;
}
# 4 "orb_all.cc" 2
# 1 "basic_seq.cc" 1
# 24 "basic_seq.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 25 "basic_seq.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 26 "basic_seq.cc" 2



void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Any,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_any, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Any,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Any,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_any, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Any,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_any, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Char,2> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_char, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Char,2> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Char,2> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_char, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Char,2> *&s )
{
  return a.to_static_any (CORBA::_stcseq_char, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Boolean,1> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_boolean, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Boolean,1> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Boolean,1> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_boolean, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Boolean,1> *&s )
{
  return a.to_static_any (CORBA::_stcseq_boolean, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Octet,3> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_octet, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Octet,3> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Octet,3> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_octet, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Octet,3> *&s )
{
  return a.to_static_any (CORBA::_stcseq_octet, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::UShort,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_ushort, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::UShort,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::UShort,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_ushort, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::UShort,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_ushort, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::ULong,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_ulong, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::ULong,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::ULong,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_ulong, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::ULong,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_ulong, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Short,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_short, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Short,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Short,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_short, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Short,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_short, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Long,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_long, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Long,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Long,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_long, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Long,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_long, (void *&)s);
}


void
operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::LongLong,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_longlong, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::LongLong,0> *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::LongLong,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_longlong, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const SequenceTmpl<CORBA::LongLong,0> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_longlong, (void *&)_s);
}


void
operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::ULongLong,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_ulonglong, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::ULongLong,0> *_s )
{
  _a <<= *_s;
  delete _s;
}


CORBA::Boolean
operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::ULongLong,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_ulonglong, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const SequenceTmpl<CORBA::ULongLong,0> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_ulonglong, (void *&)_s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Float,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_float, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Float,0> *s )
{
  a <<= *s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Float,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_float, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Float,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_float, (void *&)s);
}


void
operator<<=( CORBA::Any &a, const SequenceTmpl<CORBA::Double,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_double, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, SequenceTmpl<CORBA::Double,0> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, SequenceTmpl<CORBA::Double,0> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_double, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const SequenceTmpl<CORBA::Double,0> *&s )
{
  return a.to_static_any (CORBA::_stcseq_double, (void *&)s);
}


void
operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::LongDouble,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_longdouble, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::LongDouble,0> *_s )
{
  _a <<= *_s;
  delete _s;
}


CORBA::Boolean
operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::LongDouble,0> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_longdouble, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const SequenceTmpl<CORBA::LongDouble,0> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_longdouble, (void *&)_s);
}


void
operator<<=( CORBA::Any &_a, const SequenceTmpl<CORBA::WChar,4> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_wchar, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, SequenceTmpl<CORBA::WChar,4> *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, SequenceTmpl<CORBA::WChar,4> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_wchar, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const SequenceTmpl<CORBA::WChar,4> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_wchar, (void *&)_s);
}


void
operator<<=( CORBA::Any &_a, const WStringSequenceTmpl<CORBA::WString_var> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_wstring, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, WStringSequenceTmpl<CORBA::WString_var> *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, WStringSequenceTmpl<CORBA::WString_var> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_wstring, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const WStringSequenceTmpl<CORBA::WString_var> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_wstring, (void *&)_s);
}


void
operator<<=( CORBA::Any &a, const StringSequenceTmpl<CORBA::String_var> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_string, &s);
  a.from_static_any (sa);
}

void
operator<<=( CORBA::Any &a, StringSequenceTmpl<CORBA::String_var> *s )
{
  a <<= *s;
  delete s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &a, StringSequenceTmpl<CORBA::String_var> &s )
{
  CORBA::StaticAny sa (CORBA::_stcseq_string, &s);
  return a.to_static_any (sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &a,
             const StringSequenceTmpl<CORBA::String_var> *&s )
{
  return a.to_static_any (CORBA::_stcseq_string, (void *&)s);
}


void
operator<<=( CORBA::Any &_a,
             const IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_Object, &_s);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a,
             IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> &_s )
{
  CORBA::StaticAny _sa (CORBA::_stcseq_Object, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a,
             const IfaceSequenceTmpl<CORBA::Object_var,CORBA::Object_ptr> *&_s )
{
  return _a.to_static_any (CORBA::_stcseq_Object, (void *&)_s);
}
# 5 "orb_all.cc" 2
# 1 "boa.cc" 1
# 26 "boa.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 27 "boa.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 29 "boa.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "boa.cc" 2
# 1 "/opt/gcc3/include/g++-v3/algorithm" 1 3
# 32 "boa.cc" 2
# 1 "../include/mico/impl.h" 1
# 33 "boa.cc" 2
# 1 "../include/mico/intercept.h" 1
# 34 "boa.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 35 "boa.cc" 2
# 1 "../include/mico/util.h" 1
# 36 "boa.cc" 2
# 1 "../include/mico/os-misc.h" 1
# 37 "boa.cc" 2





CORBA::BOA::~BOA ()
{
}
# 55 "boa.cc"
class BOAInterceptImpl : public Interceptor::BOAInterceptor {
    CORBA::BOAObjectRestorer *_restorer;
public:
    BOAInterceptImpl (CORBA::BOAObjectRestorer *r)
        : _restorer (r)
    {}

    Interceptor::Status restore (CORBA::Object_ptr obj)
    {
        return _restorer->restore (obj)
            ? Interceptor::INVOKE_BREAK
            : Interceptor::INVOKE_CONTINUE;
    }

    Interceptor::Status bind (const char *repoid,
                              const CORBA::ORB::ObjectTag &tag)
    {
        return _restorer->bind (repoid, tag)
            ? Interceptor::INVOKE_BREAK
            : Interceptor::INVOKE_CONTINUE;
    }
};

CORBA::BOAObjectRestorer::BOAObjectRestorer ()
{
    Interceptor::Root_ptr rp;

    rp = new BOAInterceptImpl (this);
    rp->activate (0);
    _boa_interceptor = rp;
}

CORBA::BOAObjectRestorer::~BOAObjectRestorer ()
{
    CORBA::release (_boa_interceptor);
}

CORBA::Boolean
CORBA::BOAObjectRestorer::restore (CORBA::Object_ptr)
{
    return 0;
}

CORBA::Boolean
CORBA::BOAObjectRestorer::bind (const char *repoid,
                                const CORBA::ORB::ObjectTag &tag)
{
    return 0;
}





MICO::ObjectRecord::ObjectRecord (CORBA::Object_ptr local_obj,
                                  const CORBA::BOA::ReferenceData &refdata,
                                  CORBA::InterfaceDef_ptr ifc,
                                  CORBA::ImplementationDef_ptr im,
                                  CORBA::ImplementationBase *sk)
{
    _local_obj = local_obj;
    _remote_obj = CORBA::Object::_duplicate (local_obj);
    _id = refdata;
    _iface = CORBA::InterfaceDef::_duplicate (ifc);
    _impl = CORBA::ImplementationDef::_duplicate (im);
    _skel = sk;
    _save = 1;
    _state = BOAActive;
    _persistent = 0;
}

MICO::ObjectRecord::ObjectRecord (CORBA::Object_ptr local_obj,
                                  CORBA::Object_ptr remote_obj,
                                  const CORBA::BOA::ReferenceData &refdata,
                                  CORBA::InterfaceDef_ptr ifc,
                                  CORBA::ImplementationDef_ptr im,
                                  CORBA::ImplementationBase *sk)
{
    _local_obj = local_obj;
    _remote_obj = remote_obj;
    _id = refdata;
    _iface = CORBA::InterfaceDef::_duplicate (ifc);
    _impl = CORBA::ImplementationDef::_duplicate (im);
    _skel = sk;
    _save = 1;
    _state = BOAActive;
    _persistent = 0;
}

MICO::ObjectRecord::~ObjectRecord ()
{
    CORBA::release (_local_obj);
    CORBA::release (_remote_obj);
    CORBA::release (_iface);
    CORBA::release (_impl);

}

CORBA::BOA::ReferenceData *
MICO::ObjectRecord::id ()
{
    return &_id;
}

CORBA::ImplementationDef_ptr
MICO::ObjectRecord::impl ()
{
    return _impl;
}

void
MICO::ObjectRecord::impl (CORBA::ImplementationDef_ptr im)
{
    CORBA::release (_impl);
    _impl = CORBA::ImplementationDef::_duplicate (im);
}

CORBA::InterfaceDef_ptr
MICO::ObjectRecord::iface ()
{
    return _iface;
}

void
MICO::ObjectRecord::iface (CORBA::InterfaceDef_ptr ifc)
{
    CORBA::release (_iface);
    _iface = CORBA::InterfaceDef::_duplicate (ifc);
}

CORBA::Object_ptr
MICO::ObjectRecord::local_obj ()
{
    return _local_obj;
}

CORBA::Object_ptr
MICO::ObjectRecord::remote_obj ()
{
    return _remote_obj;
}

CORBA::ImplementationBase *
MICO::ObjectRecord::skel ()
{
    return _skel;
}

void
MICO::ObjectRecord::skel (CORBA::ImplementationBase *sk)
{
    _skel = sk;
}

void
MICO::ObjectRecord::save (CORBA::Boolean save)
{
    _save = save;
}

CORBA::Boolean
MICO::ObjectRecord::save () const
{
    return _save;
}

void
MICO::ObjectRecord::persistent (CORBA::Boolean p)
{
    _persistent = p;
}

CORBA::Boolean
MICO::ObjectRecord::persistent () const
{
    return _persistent;
}

void
MICO::ObjectRecord::state (BOAState state)
{
    _state = state;
}

MICO::BOAState
MICO::ObjectRecord::state () const
{
    return _state;
}





MICO::BOAServImpl::BOAServImpl (BOAImpl *__boa)
{
    _boa = __boa;
}

MICO::BOAServImpl::~BOAServImpl ()
{
}

void
MICO::BOAServImpl::restore_request (const CORBA::OAServer::ObjSeq &objs)
{
    for (CORBA::ULong i = 0; i < objs.length(); ++i)
        _boa->restore_internal (objs[i].in());
}

void
MICO::BOAServImpl::obj_inactive (CORBA::Object_ptr obj)
{
    ObjectRecord *rec = _boa->get_record (obj);
    if (rec) {
        ((void) ((rec->state() == BOAShutdown) ? 0 : (__assert_fail ("rec->state() == BOAShutdown", "boa.cc", 270, __PRETTY_FUNCTION__), 0)));
        rec->state (BOAInactive);
    }
}

void
MICO::BOAServImpl::impl_inactive ()
{
    ((void) ((_boa->_state == BOAShutdown) ? 0 : (__assert_fail ("_boa->_state == BOAShutdown", "boa.cc", 278, __PRETTY_FUNCTION__), 0)));
    _boa->_state = BOAInactive;
}
# 290 "boa.cc"
MICO::BOAImpl::BOAImpl (CORBA::ORB_ptr theorb, int &argc, char **argv)
    : _queue (this, theorb)
{
    _restoring = 0;
    _state = BOAActive;
    _active_obj = CORBA::Object::_nil();
    _curr_environ = CORBA::Environment::_nil();
    _amode = CORBA::ImplementationDef::ActivatePersistent;
    _oasrv_id = 0;
    _queue_count = 0;

    _orb = theorb;
    _theid = 0;
    _orb->register_oa (this);

    vector<CORBA::Octet> hostid = MICO::InetAddress::hostid();
    CORBA::ULong pid = OSMisc::getpid();
    _id_template[0] = 'B';
    _id_template[1] = 'O';
    _id_template[2] = 'A';
    _id_template[3] = hostid[0];
    _id_template[4] = hostid[1];
    _id_template[5] = hostid[2];
    _id_template[6] = hostid[3];
    _id_template[7] = (CORBA::Octet)(pid >> 24);
    _id_template[8] = (CORBA::Octet)(pid >> 16);
    _id_template[9] = (CORBA::Octet)(pid >> 8);
    _id_template[10] = (CORBA::Octet)(pid);

    string remote_ior;
    string remote_addr;
    typedef vector<string> vec_of_string;
    vec_of_string restore_iors;
    MICOGetOpt::OptMap opts;
    opts["-OARemoteIOR"] = "arg-expected";
    opts["-OARemoteAddr"] = "arg-expected";
    opts["-OARestoreIOR"] = "arg-expected";
    opts["-OAImplName"] = "arg-expected";
    opts["-OAServerId"] = "arg-expected";

    MICOGetOpt opt_parser (opts);
    CORBA::Boolean r = opt_parser.parse ("~/.micorc", 1);
    ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 332, __PRETTY_FUNCTION__), 0)));
    r = opt_parser.parse (argc, argv, 1);
    ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 334, __PRETTY_FUNCTION__), 0)));
    const MICOGetOpt::OptVec &o = opt_parser.opts();

    for (MICOGetOpt::OptVec::const_iterator i = o.begin(); i != o.end(); ++i) {
        string arg = (*i).first;
        string val = (*i).second;
        if (arg == "-OARemoteIOR") {
            remote_ior = val;
        } else if (arg == "-OARemoteAddr") {
            remote_addr = val;
        } else if (arg == "-OARestoreIOR") {
            restore_iors.push_back (val);
        } else if (arg == "-OAServerId") {
            _oasrv_id = atoi (val.c_str());
        } else if (arg == "-OAImplName") {
            _impl_name = val;
        }
    }


    _oamed = CORBA::OAMediator::_nil();
    _oasrv = CORBA::OAServer::_nil();
    CORBA::Object_var obj = CORBA::Object::_nil();
    if (remote_ior.length() > 0) {
        obj = _orb->string_to_object (remote_ior.c_str());
        ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "boa.cc", 359, __PRETTY_FUNCTION__), 0)));
    } else if (remote_addr.length() > 0) {
        obj = _orb->bind ("IDL:omg.org/CORBA/OAMediator:1.0",
                          remote_addr.c_str());
        ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "boa.cc", 363, __PRETTY_FUNCTION__), 0)));
    }
    if (!CORBA::is_nil (obj)) {
        _oamed = CORBA::OAMediator::_narrow (obj);
        ((void) ((!CORBA::is_nil (_oamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (_oamed)", "boa.cc", 367, __PRETTY_FUNCTION__), 0)));
    }

    if (!CORBA::is_nil (_oamed)) {




        _oasrv = new BOAServImpl (this);


        CORBA::ImplementationDef_var impl = find_impl ();
        _amode = impl->mode();
        _oamed->create_impl (impl, _oasrv, _oasrv_id);
    }


    if (restore_iors.size() > 0) {
        _restoring = 1;
        for (mico_vec_size_type i = 0; i < restore_iors.size(); ++i) {
            obj = _orb->string_to_object (restore_iors[i].c_str());
            ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "boa.cc", 388, __PRETTY_FUNCTION__), 0)));
            restore_internal (obj);
        }
    }

    if (!CORBA::is_nil (_oamed)) {
        CORBA::OAMediator::ObjSeq_var robjs =
            _oamed->get_restore_objs (_oasrv_id);

        if (robjs->length() > 0) {
            _restoring = 1;
            for (CORBA::ULong i = 0; i < robjs->length(); ++i)
                restore_internal (robjs[i]);
        }
    }
}

MICO::BOAImpl::~BOAImpl ()
{
    _orb->unregister_oa (this);
    for (MapObjRec::iterator i0 = _lobjs.begin(); i0 != _lobjs.end(); ++i0) {
        ObjectRecord *rec = (*i0).second;
        delete rec;
    }


    for (ListShlib::iterator i1 = _shlibs.begin(); i1 != _shlibs.end(); ++i1)

        delete *i1;





    CORBA::release (_oamed);
    CORBA::release (_oasrv);
}

void
MICO::BOAImpl::add_record (ObjectRecord *rec)
{
    _lobjs[rec->local_obj()] = rec;
    if (!CORBA::is_nil (_oamed))
        _robjs[rec->remote_obj()] = rec;
}

MICO::ObjectRecord *
MICO::BOAImpl::get_record (CORBA::Object_ptr o)
{
    MapObjRec::iterator i = _lobjs.find (o);
    if (i != _lobjs.end())
        return (*i).second;

    if (CORBA::is_nil (_oamed))
        return 0;




    i = _robjs.find (o);
    return i != _robjs.end() ? (*i).second : 0;
}

void
MICO::BOAImpl::del_record (CORBA::Object_ptr o)
{
    MapObjRec::iterator i = _lobjs.find (o);
    if (i != _lobjs.end()) {
        if (!CORBA::is_nil (_oamed))
            _robjs.erase ((*i).second->remote_obj());




        ObjectRecord *orec = (*i).second;
        _lobjs.erase (i);
        delete orec;
        return;
    }


    ((void) ((!CORBA::is_nil (_oamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (_oamed)", "boa.cc", 469, __PRETTY_FUNCTION__), 0)));

    if ((i = _robjs.find (o)) != _robjs.end()) {
        _lobjs.erase ((*i).second->local_obj());

        ObjectRecord *orec = (*i).second;
        _robjs.erase (i);
        delete orec;
        return;
    }


    ((void) ((0) ? 0 : (__assert_fail ("0", "boa.cc", 481, __PRETTY_FUNCTION__), 0)));
}

void
MICO::BOAImpl::del_all_records ()
{
    while (_lobjs.size()) {

        MapObjRec::iterator i = _lobjs.begin();
        ObjectRecord *orec = (*i).second;
        _lobjs.erase (i);
        delete orec;
    }
    _robjs.erase (_robjs.begin(), _robjs.end());
}

CORBA::ImplementationDef_ptr
MICO::BOAImpl::find_impl ()
{
    CORBA::Object_var obj =
        orb()->resolve_initial_references ("ImplementationRepository");
    CORBA::ImplRepository_var imr = CORBA::ImplRepository::_narrow (obj);

    if (CORBA::is_nil (imr)) {
      return CORBA::ImplementationDef::_nil ();
    }

    CORBA::ImplRepository::ImplDefSeq_var impls =
        imr->find_by_name (impl_name());
    if (impls->length() == 0)
        return CORBA::ImplementationDef::_nil();
    return CORBA::ImplementationDef::_duplicate (impls[(CORBA::ULong)0]);
}

CORBA::Object_ptr
MICO::BOAImpl::find_obj ()
{
    MapObjRec::iterator i = _lobjs.begin();
    if (i == _lobjs.end())
        return CORBA::Object::_nil();
    ObjectRecord *rec = (*i).second;
    return rec->remote_obj();
}

void
MICO::BOAImpl::unique_id (vector<CORBA::Octet> &id)
{
    id.insert (id.end(), _id_template, _id_template + sizeof (_id_template));

    if (++_theid == 0)
        _theid = 1;

    CORBA::ULong l = _theid;
    while (l) {
        id.push_back ((CORBA::Octet)l);
        l >>= 8;
    }
}

void
MICO::BOAImpl::queue ()
{
    ++_queue_count;
}

void
MICO::BOAImpl::unqueue ()
{
    ((void) ((_queue_count > 0) ? 0 : (__assert_fail ("_queue_count > 0", "boa.cc", 549, __PRETTY_FUNCTION__), 0)));
    if (--_queue_count == 0)
        _queue.exec_later ();
}

CORBA::Boolean
MICO::BOAImpl::must_queue (MsgId id)
{
    if (_queue_count > 0)
        return 1;
    if (_queue.size() == 0)
        return 0;
    if (_queue.iscurrent (id))
        return 0;




    return 1;
}

CORBA::Boolean
MICO::BOAImpl::is_active_object (CORBA::Object_ptr obj)
{
    if (CORBA::is_nil (obj) && CORBA::is_nil (_active_obj))
        return 1;
    if (CORBA::is_nil (obj) || CORBA::is_nil (_active_obj))
        return 0;
    return _active_obj->_is_equivalent (obj);
}

CORBA::Object_ptr
MICO::BOAImpl::create (const ReferenceData &id,
                       CORBA::InterfaceDef_ptr interf,
                       CORBA::ImplementationDef_ptr impl,
                       CORBA::ImplementationBase *skel,
                       const char *repoid)
{
    vector<CORBA::Octet> key;
    unique_id (key);

    CORBA::IOR *ior = new CORBA::IOR (*_orb->ior_template());
    ior->objectkey (&key[0], key.size());

    ((void) ((repoid) ? 0 : (__assert_fail ("repoid", "boa.cc", 593, __PRETTY_FUNCTION__), 0)));
    ior->objid (repoid);

    CORBA::Object_ptr obj = new CORBA::Object (ior);

    obj->_setup_domains (CORBA::Object::_nil());

    ObjectRecord *rec;







    if (skel && skel->_ior())
        dispose (skel);


    CORBA::Boolean retval = Interceptor::BOAInterceptor::_exec_create (obj);

    ((void) ((retval) ? 0 : (__assert_fail ("retval", "boa.cc", 614, __PRETTY_FUNCTION__), 0)));

    if (CORBA::is_nil (_oamed) || CORBA::is_nil (_oasrv)) {



        rec = new ObjectRecord (obj, id, interf, impl, skel);
        add_record (rec);
    } else {





        queue ();

        CORBA::Object_ptr remote_obj;
        _oamed->create_obj (obj, id, remote_obj, _oasrv_id);
        ((void) ((!CORBA::is_nil (remote_obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (remote_obj)", "boa.cc", 632, __PRETTY_FUNCTION__), 0)));
        _oamed->activate_obj (remote_obj, _oasrv_id);

        rec = new ObjectRecord (obj, remote_obj, id, interf, impl, skel);
        add_record (rec);

        unqueue ();
    }

    return CORBA::Object::_duplicate (rec->remote_obj());
}

CORBA::Boolean
MICO::BOAImpl::restoring ()
{
    return _restoring;
}

void
MICO::BOAImpl::restore_internal (CORBA::Object_ptr orig)
{
    vector<CORBA::Octet> key;
    unique_id (key);

    CORBA::IOR *ior = new CORBA::IOR (*_orb->ior_template());
    ior->objectkey (&key[0], key.size());

    ior->objid (orig->_repoid());

    CORBA::Object_ptr obj = new CORBA::Object (ior);
    ObjectRecord *rec;

    ((void) ((!CORBA::is_nil (_oamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (_oamed)", "boa.cc", 664, __PRETTY_FUNCTION__), 0)));







    queue ();

    ReferenceData_var id;
    CORBA::Object_var remote_obj = CORBA::Object::_duplicate (orig);
    _oamed->restore_obj (obj, remote_obj.inout(), id, _oasrv_id);
    ((void) ((!CORBA::is_nil (remote_obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (remote_obj)", "boa.cc", 677, __PRETTY_FUNCTION__), 0)));
    _oamed->activate_obj (remote_obj, _oasrv_id);

    rec = new ObjectRecord (obj, remote_obj._retn(), id.in(),
                            CORBA::InterfaceDef::_nil(),
                            CORBA::ImplementationDef::_nil(),
                            (CORBA::ImplementationBase *)0);
    add_record (rec);

    unqueue ();
}

CORBA::Object_ptr
MICO::BOAImpl::restore (CORBA::Object_ptr orig,
                        const ReferenceData &_id,
                        CORBA::InterfaceDef_ptr interf,
                        CORBA::ImplementationDef_ptr impl,
                        CORBA::ImplementationBase *skel)
{
    ObjectRecord *rec = get_record (orig);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 697, __PRETTY_FUNCTION__), 0)));
    ((void) ((!CORBA::is_nil (_oamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (_oamed)", "boa.cc", 698, __PRETTY_FUNCTION__), 0)));

    rec->iface (interf);
    rec->impl (impl);
    rec->skel (skel);

    return CORBA::Object::_duplicate (rec->remote_obj());
}

void
MICO::BOAImpl::dispose (CORBA::Object_ptr o)
{
    ObjectRecord *rec = get_record (o);

    if (rec) {
        if (is_active_object (o))
            _active_obj = CORBA::Object::_nil();

        if (CORBA::is_nil (_oamed) || rec->local_obj() == rec->remote_obj()) {
            del_record (o);
        } else {





            CORBA::Object_var obj =
                new CORBA::Object (new CORBA::IOR (*o->_ior()));
            del_record (o);
            _oamed->dispose_obj (obj, _oasrv_id);
        }
    }
}

CORBA::ORB_ptr
MICO::BOAImpl::orb ()
{
    return _orb;
}

CORBA::BOA::ReferenceData *
MICO::BOAImpl::get_id (CORBA::Object_ptr o)
{
    ObjectRecord *rec = get_record (o);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 742, __PRETTY_FUNCTION__), 0)));
    return new ReferenceData (*rec->id ());
}

CORBA::Principal_ptr
MICO::BOAImpl::get_principal (CORBA::Object_ptr o, CORBA::Environment_ptr env)
{
    if (!CORBA::is_nil (env))
        return CORBA::Principal::_duplicate (env->principal ());
    if (!CORBA::is_nil (_curr_environ))
        return CORBA::Principal::_duplicate (_curr_environ->principal());
    return CORBA::Principal::_nil();
}

void
MICO::BOAImpl::shutdown_obj (CORBA::Object_ptr obj)
{
    ((void) ((_queue_count == 0) ? 0 : (__assert_fail ("_queue_count == 0", "boa.cc", 759, __PRETTY_FUNCTION__), 0)));
    _queue.exec_now();

    if (CORBA::is_nil (_oamed))
        return;

    _oamed->deactivate_obj (obj, _oasrv_id);

    while (42) {
        ObjectRecord *rec = get_record (obj);
        if (!rec) {

            break;
        }
        if (rec->state() == BOAInactive)

            break;
        _orb->dispatcher()->run (0);
    }
}

void
MICO::BOAImpl::shutdown_impl ()
{
    ((void) ((_queue_count == 0) ? 0 : (__assert_fail ("_queue_count == 0", "boa.cc", 783, __PRETTY_FUNCTION__), 0)));
    _queue.exec_now();

    if (CORBA::is_nil (_oamed))
        return;

    _oamed->deactivate_impl (_oasrv_id);

    while (42) {
        if (_state == BOAInactive)

            break;
        _orb->dispatcher()->run (0);
    }
}

void
MICO::BOAImpl::change_implementation (CORBA::Object_ptr o,
                                      CORBA::ImplementationDef_ptr im)
{

    ((void) ((!CORBA::is_nil (_oamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (_oamed)", "boa.cc", 804, __PRETTY_FUNCTION__), 0)));
    ((void) ((!CORBA::is_nil (im)) ? 0 : (__assert_fail ("!CORBA::is_nil (im)", "boa.cc", 805, __PRETTY_FUNCTION__), 0)));

    ObjectRecord *rec = get_record (o);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 808, __PRETTY_FUNCTION__), 0)));

    if (rec->state() == BOAActive) {
        rec->state (BOAShutdown);

        shutdown_obj (o);
        save_object (rec);

        _oamed->migrate_obj (o, _oasrv_id, im);

        dispose_object (rec);
        del_record (o);
    }
}

void
MICO::BOAImpl::impl_is_ready (CORBA::ImplementationDef_ptr im)
{
    if (!CORBA::is_nil (_oamed)) {




        _oamed->activate_impl (_oasrv_id);
    }
}

void
MICO::BOAImpl::deactivate_impl (CORBA::ImplementationDef_ptr im)
{
    if (_state == BOAActive) {
        _state = BOAShutdown;

        shutdown_impl ();
        save_objects ();


        dispose_objects ();

        if (!CORBA::is_nil (_oamed))
            _oamed->dispose_impl (_oasrv_id);

        del_all_records ();
    }
}

void
MICO::BOAImpl::obj_is_ready (CORBA::Object_ptr o,
                             CORBA::ImplementationDef_ptr im)
{
    if (CORBA::is_nil (o)) {
        o = find_obj ();
    }

    _active_obj = o;

    if (!CORBA::is_nil (_oamed)) {




        _oamed->activate_impl (_oasrv_id);
    }
}

void
MICO::BOAImpl::deactivate_obj (CORBA::Object_ptr o)
{
    if (CORBA::is_nil (o)) {
        o = _active_obj;

    }

    if (is_active_object (o)) {

        if (_state == BOAActive) {
            _state = BOAShutdown;

            shutdown_impl ();
            save_objects ();


            dispose_objects ();

            if (!CORBA::is_nil (_oamed))
                _oamed->dispose_impl (_oasrv_id);

            del_all_records ();
        }
    } else {

        ((void) ((!CORBA::is_nil (o)) ? 0 : (__assert_fail ("!CORBA::is_nil (o)", "boa.cc", 899, __PRETTY_FUNCTION__), 0)));

        ObjectRecord *rec = get_record (o);
        ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 902, __PRETTY_FUNCTION__), 0)));

        if (rec->state() == BOAActive) {
            rec->state (BOAShutdown);

            shutdown_obj (o);
            save_object (rec);

            if (!CORBA::is_nil (_oamed))
                _oamed->orphan_obj (o, _oasrv_id);

            dispose_object (rec);

            del_record (o);
        }
    }
}

const char *
MICO::BOAImpl::get_oaid () const
{
    return "mico-local-boa";
}

CORBA::Boolean
MICO::BOAImpl::has_object (CORBA::Object_ptr o)
{
    CORBA::IORProfile *prof;
    if (CORBA::is_nil (o) || !o->_ior() || !(prof = o->_ior()->profile()))
        return 0;

    CORBA::Long objkeylen;
    const CORBA::Octet *objkey = prof->objectkey (objkeylen);
    if (objkeylen >= sizeof (_id_template) &&
        !memcmp (objkey, _id_template, sizeof (_id_template)))
        return 1;

    if (!CORBA::is_nil (_oamed) && objkeylen >= 3 && !memcmp (objkey, "OAD", 3))
        return _robjs.count (o) > 0;

    return 0;
}

CORBA::Boolean
MICO::BOAImpl::is_local () const
{
    return 1;
}

CORBA::ImplementationDef_ptr
MICO::BOAImpl::get_impl (CORBA::Object_ptr o)
{
    ObjectRecord *rec = get_record (o);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 955, __PRETTY_FUNCTION__), 0)));
    CORBA::Boolean r = load_object (rec);
    ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 957, __PRETTY_FUNCTION__), 0)));
    return rec->impl ();
}

CORBA::InterfaceDef_ptr
MICO::BOAImpl::get_iface (CORBA::Object_ptr o)
{
    ObjectRecord *rec = get_record (o);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 965, __PRETTY_FUNCTION__), 0)));
    CORBA::Boolean r = load_object (rec);
    ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 967, __PRETTY_FUNCTION__), 0)));
    if (CORBA::is_nil (rec->iface())) {
        rec->iface (rec->skel()->_find_iface (rec->local_obj()->_repoid()));
    }
    return rec->iface ();
}

CORBA::Boolean
MICO::BOAImpl::is_builtin_invoke (const char *opname)
{
    if (opname[0] != '_')
        return 0;
    return
        !strcmp (opname, "_interface") ||
        !strcmp (opname, "_implementation") ||
        !strcmp (opname, "_is_a") ||
        !strcmp (opname, "_non_existent");
}

void
MICO::BOAImpl::builtin_invoke (CORBA::Object_ptr o,
                               CORBA::ServerRequest_ptr svreq,
                               CORBA::Principal_ptr pr)
{

    if (!strcmp (svreq->op_name(), "_interface")) {
        CORBA::NVList_ptr args;
        _orb->create_list (0, args);
        if (svreq->params (args)) {
            CORBA::Any *res = new CORBA::Any;
            *res <<= get_iface (o);
            svreq->result (res);
        }
        return;
    }
    if (!strcmp (svreq->op_name(), "_implementation")) {
        CORBA::NVList_ptr args;
        _orb->create_list (0, args);
        if (svreq->params (args)) {
            CORBA::Any *res = new CORBA::Any;
            *res <<= get_impl (o);
            svreq->result (res);
        }
        return;
    }
    if (!strcmp (svreq->op_name(), "_is_a")) {
        CORBA::NVList_ptr args;
        _orb->create_list (0, args);
        args->add (CORBA::ARG_IN);
        args->item(0)->value()->set_type (CORBA::_tc_string);
        if (svreq->params (args)) {
            const char *repoid;
            CORBA::Boolean r = (*args->item(0)->value() >>= repoid);
            ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 1020, __PRETTY_FUNCTION__), 0)));

            ObjectRecord *rec = get_record (o);
            ((void) ((rec) ? 0 : (__assert_fail ("rec", "boa.cc", 1023, __PRETTY_FUNCTION__), 0)));
            r = load_object (rec);
            ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 1025, __PRETTY_FUNCTION__), 0)));
            CORBA::Boolean isa = rec->skel()->_is_a (repoid);

            CORBA::Any *res = new CORBA::Any;
            *res <<= CORBA::Any::from_boolean (isa);
            svreq->result (res);
        }
        return;
    }
    if (!strcmp (svreq->op_name(), "_non_existent")) {
        CORBA::NVList_ptr args;
        _orb->create_list (0, args);
        if (svreq->params (args)) {
            CORBA::Any *res = new CORBA::Any;
            *res <<= CORBA::Any::from_boolean (0);
            svreq->result (res);
        }
        return;
    }
}

CORBA::Boolean
MICO::BOAImpl::invoke (MsgId msgid,
                       CORBA::Object_ptr o,
                       CORBA::ORBRequest *req,
                       CORBA::Principal_ptr pr,
                       CORBA::Boolean response_exp)
{
    if (must_queue (msgid)) {
        _queue.add (new MICO::ReqQueueRec (msgid, req, o, pr, response_exp));
        return 1;
    }





    ObjectRecord *rec = get_record (o);
    if ((_state != BOAActive || !rec || rec->state() != BOAActive) &&
        !CORBA::is_nil (_oamed) &&
        (!rec || !_oasrv->_is_equivalent (rec->local_obj()))) {


        CORBA::Long objkeylen;
        const CORBA::Octet *objkey =
            o->_ior()->profile()->objectkey (objkeylen);

        CORBA::OAMediator::RefData key;
        key.length (objkeylen);
        memcpy (&key[0], objkey, objkeylen);

        queue();
        CORBA::Object_var fwd_obj = _oamed->get_remote_object (key);
        unqueue();
        ((void) ((!CORBA::is_nil (fwd_obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (fwd_obj)", "boa.cc", 1079, __PRETTY_FUNCTION__), 0)));

        _orb->answer_invoke (msgid, CORBA::InvokeForward, fwd_obj, req, 0);
        return 1;
    }
    if (!rec) {




        CORBA::OBJECT_NOT_EXIST ex;
        req->set_out_args (&ex);
        _orb->answer_invoke (msgid, CORBA::InvokeSysEx,
                             CORBA::Object::_nil(), req, 0);
        return 1;
    }

    if (is_builtin_invoke (req->op_name())) {
        CORBA::ServerRequest_var svreq
            = new CORBA::ServerRequest (req, o, msgid, this, pr);

        builtin_invoke (o, svreq, pr);
    } else {
        CORBA::Boolean r = load_object (rec);
        ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 1103, __PRETTY_FUNCTION__), 0)));
        CORBA::ImplementationBase *skel = rec->skel ();
        ((void) ((skel) ? 0 : (__assert_fail ("skel", "boa.cc", 1105, __PRETTY_FUNCTION__), 0)));

        CORBA::ServerRequestBase_var svreq
            = skel->make_request (req, o, msgid, this, pr);







        _curr_environ = svreq->environment();
        skel->doinvoke (svreq, *svreq->environment());
        _curr_environ = CORBA::Environment::_nil();
    }
    return 1;
}

void
MICO::BOAImpl::answer_invoke (MsgId msgid,
                              CORBA::Object_ptr obj,
                              CORBA::ORBRequest *req,
                              CORBA::InvokeStatus stat)
{
    _orb->answer_invoke (msgid, stat, CORBA::Object::_nil(), req, 0);

    if (_amode == CORBA::ImplementationDef::ActivatePerMethod) {

        if (!is_builtin_invoke (req->op_name()))
            _orb->shutdown (1);
    }
}

CORBA::Boolean
MICO::BOAImpl::activate (const char *repoid)
{
    CORBA::Object_var obj =
        _orb->resolve_initial_references ("ImplementationRepository");
    CORBA::ImplRepository_var imr = CORBA::ImplRepository::_narrow (obj);
    if (CORBA::is_nil (imr)) {
      return 0;
    }

    CORBA::ImplRepository::ImplDefSeq_var ims = imr->find_by_repoid (repoid);

    for (CORBA::ULong i = 0; i < ims->length(); ++i) {
        if (ims[i]->mode() == CORBA::ImplementationDef::ActivateLibrary) {
            CORBA::String_var name = ims[i]->command();


            ListShlib::iterator j;
            for (j = _shlibs.begin(); j != _shlibs.end(); ++j) {
                if (!strcmp ((*j)->name(), name))
                    break;
            }
            if (j != _shlibs.end())

                continue;


            if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
              MICO::Logger::Stream (MICO::Logger::Info)
                << "Info: BOA: loading shlib " << name.in() << endl;
            }

            MICO::SharedLib *shlib = new UnixSharedLib (name);
            if (!*shlib) {
              if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
                MICO::Logger::Stream (MICO::Logger::Error)
                  << "Info: BOA: could not load shlib " << name.in() << ": "
                  << shlib->error() << endl;
              }
              delete shlib;
              continue;
            }
# 1188 "boa.cc"
            _shlibs.push_back (shlib);

            if (!shlib->init ()) {
              if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
                MICO::Logger::Stream (MICO::Logger::Warning)
                  << "Warning: BOA: could not init shlib " << name.in()
                  << endl;
              }
              continue;
            }
            return 1;
        }
    }
    return 0;
}

CORBA::Boolean
MICO::BOAImpl::dobind (MsgId msgid, const char *repoid,
                       const CORBA::ORB::ObjectTag &oid,
                       CORBA::Address *addr)
{
    for (MapObjRec::iterator i=_lobjs.begin(); i != _lobjs.end(); ++i) {
        ObjectRecord *rec = (*i).second;

        if (!strcmp (repoid, rec->local_obj()->_repoid()) &&
            (oid.length() == 0 || oid == *rec->id())) {
            CORBA::Boolean r = load_object (rec);
            ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 1215, __PRETTY_FUNCTION__), 0)));
            _orb->answer_bind (msgid, CORBA::LocateHere, rec->skel());
            return 1;
        }
    }
    return 0;
}

CORBA::Boolean
MICO::BOAImpl::bind (MsgId msgid, const char *repoid,
                     const CORBA::ORB::ObjectTag &oid,
                     CORBA::Address *addr)
{
    if (addr && !addr->is_local())

        return 0;

    if (must_queue (msgid)) {
        _queue.add (new MICO::ReqQueueRec (msgid, repoid, oid));
        return 1;
    }

    queue();
    while (42) {
        if (dobind (msgid, repoid, oid, addr)) {
            unqueue();
            return 1;
        }


        if (!activate (repoid))
            break;
    }

    CORBA::Boolean ret = Interceptor::BOAInterceptor::_exec_bind (repoid, oid);

    if (ret && dobind (msgid, repoid, oid, addr)) {
        unqueue();
        return 1;
    }
    unqueue();

    return 0;
}

CORBA::Boolean
MICO::BOAImpl::locate (MsgId msgid, CORBA::Object_ptr o)
{
    _orb->answer_locate (msgid, CORBA::LocateHere, CORBA::Object::_nil(), 0);
    return 1;
}

CORBA::Object_ptr
MICO::BOAImpl::skeleton (CORBA::Object_ptr o)
{
    ObjectRecord *rec = get_record (o);
    if (!rec)
        return CORBA::Object::_nil();
    CORBA::Boolean r = load_object (rec);
    ((void) ((r) ? 0 : (__assert_fail ("r", "boa.cc", 1274, __PRETTY_FUNCTION__), 0)));
    return CORBA::Object::_duplicate (rec->skel ());
}

void
MICO::BOAImpl::cancel (MsgId msgid)
{
}

void
MICO::BOAImpl::shutdown (CORBA::Boolean wait_for_completion)
{
    if (_amode == CORBA::ImplementationDef::ActivatePerMethod)

        deactivate_obj (CORBA::Object::_nil());

    save_objects ();
    dispose_objects();


    _orb->answer_shutdown (this);
}

const char *
MICO::BOAImpl::impl_name ()
{
    if (_impl_name.length() == 0) {

        _impl_name = InetAddress::hostname ();
        _impl_name += ":";
        _impl_name += xdec (OSMisc::getpid());
    }
    return _impl_name.c_str();
}

void
MICO::BOAImpl::save_objects ()
{
    for (MapObjRec::iterator i = _lobjs.begin(); i != _lobjs.end(); ++i) {
        ObjectRecord *rec = (*i).second;
        save_object (rec);
    }
}

void
MICO::BOAImpl::save_object (ObjectRecord *rec)
{
    if (rec->skel() && rec->save() && rec->local_obj() != rec->remote_obj()) {
        rec->persistent (rec->skel()->_save_object());
        rec->save (0);
    }
}

void
MICO::BOAImpl::dispose_objects ()
{
    for (MapObjRec::iterator i = _lobjs.begin(); i != _lobjs.end(); ++i) {
        ObjectRecord *rec = (*i).second;
        dispose_object (rec);
    }
}

void
MICO::BOAImpl::dispose_object (ObjectRecord *rec)
{
    if (rec->skel() && rec->local_obj() != rec->remote_obj()) {
        CORBA::Boolean r = rec->save();
        ((void) ((!r) ? 0 : (__assert_fail ("!r", "boa.cc", 1341, __PRETTY_FUNCTION__), 0)));
        if (!rec->persistent() && !CORBA::is_nil (_oamed)) {
            _oamed->dispose_obj (rec->remote_obj(), _oasrv_id);
        }
    }
}

CORBA::Boolean
MICO::BOAImpl::load_object (ObjectRecord *rec)
{
    if (rec->skel())
        return 1;







    queue ();
    CORBA::Boolean ret;
    ret = Interceptor::BOAInterceptor::_exec_restore (rec->remote_obj());
    unqueue ();

    if (!ret)
        return 0;

    return !!rec->skel();
}
# 6 "orb_all.cc" 2
# 1 "buffer.cc" 1
# 23 "buffer.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 24 "buffer.cc" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 25 "buffer.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 26 "buffer.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 27 "buffer.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iomanip.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/iomanip.h" 3
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 32 "/opt/gcc3/include/g++-v3/iomanip.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iomanip.h" 1 3
# 37 "/opt/gcc3/include/g++-v3/bits/std_iomanip.h" 3
# 1 "/opt/gcc3/i686-pc-linux-gnu/include/g++-v3/bits/c++config.h" 1 3
# 38 "/opt/gcc3/include/g++-v3/bits/std_iomanip.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 1 3
# 39 "/opt/gcc3/include/g++-v3/bits/std_iomanip.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_functional.h" 1 3
# 18 "/opt/gcc3/include/g++-v3/bits/std_functional.h" 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_config.h" 1 3
# 19 "/opt/gcc3/include/g++-v3/bits/std_functional.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_cstddef.h" 1 3
# 20 "/opt/gcc3/include/g++-v3/bits/std_functional.h" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/stl_function.h" 1 3
# 21 "/opt/gcc3/include/g++-v3/bits/std_functional.h" 2 3
# 40 "/opt/gcc3/include/g++-v3/bits/std_iomanip.h" 2 3

namespace std {

  struct _Resetiosflags { ios_base::fmtflags _M_mask; };

  inline _Resetiosflags
  resetiosflags(ios_base::fmtflags __mask)
  {
    _Resetiosflags __x;
    __x._M_mask = __mask;
    return __x;
  }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Resetiosflags __f)
    {
      __is.setf(ios_base::fmtflags(0), __f._M_mask);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Resetiosflags __f)
    {
      __os.setf(ios_base::fmtflags(0), __f._M_mask);
      return __os;
    }


  struct _Setiosflags { ios_base::fmtflags _M_mask; };

  inline _Setiosflags
  setiosflags (ios_base::fmtflags __mask)
  {
    _Setiosflags __x;
    __x._M_mask = __mask;
    return __x;
  }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Setiosflags __f)
    {
      __is.setf(__f._M_mask);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Setiosflags __f)
    {
      __os.setf(__f._M_mask);
      return __os;
    }


  struct _Setbase { int _M_base; };

  inline _Setbase
  setbase (int __base)
  {
    _Setbase __x;
    __x._M_base = __base;
    return __x;
  }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Setbase __f)
    {
      __is.setf(__f._M_base == 8 ? ios_base::oct :
              __f._M_base == 10 ? ios_base::dec :
              __f._M_base == 16 ? ios_base::hex :
              ios_base::fmtflags(0), ios_base::basefield);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Setbase __f)
    {
      __os.setf(__f._M_base == 8 ? ios_base::oct :
                __f._M_base == 10 ? ios_base::dec :
                __f._M_base == 16 ? ios_base::hex :
                ios_base::fmtflags(0), ios_base::basefield);
      return __os;
    }


  template<class _CharT>
    struct _Setfill { _CharT _M_c; };

  template<class _CharT>
    _Setfill<_CharT>
    setfill(_CharT __c)
    {
      _Setfill<_CharT> __x;
      __x._M_c = __c;
      return __x;
    }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };

  inline _Setprecision
  setprecision(int __n)
  {
    _Setprecision __x;
    __x._M_n = __n;
    return __x;
  }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Setprecision __f)
    {
      __is.precision(__f._M_n);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Setprecision __f)
    {
      __os.precision(__f._M_n);
      return __os;
    }


  struct _Setw { int _M_n; };

  inline _Setw
  setw(int __n)
  {
    _Setw __x;
    __x._M_n = __n;
    return __x;
  }

  template <class _CharT, class _Traits>
    basic_istream<_CharT,_Traits>&
    operator>>(basic_istream<_CharT,_Traits>& __is, _Setw __f)
    {
      __is.width(__f._M_n);
      return __is;
    }

  template <class _CharT, class _Traits>
    basic_ostream<_CharT,_Traits>&
    operator<<(basic_ostream<_CharT,_Traits>& __os, _Setw __f)
    {
      __os.width(__f._M_n);
      return __os;
    }

}
# 33 "/opt/gcc3/include/g++-v3/iomanip.h" 2 3

using std::resetiosflags;
using std::setiosflags;
using std::setbase;
using std::setfill;
using std::setprecision;
using std::setw;
# 28 "buffer.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 29 "buffer.cc" 2

CORBA::Buffer::Buffer (void *b)
{

    _len = _wptr = 0x7fffffff;
    _rptr = 0;
    _ralignbase = _walignbase = 0;
    _buf = (Octet *)b;
    _readonly = 1;
}

CORBA::Buffer::Buffer (ULong sz)
{

    if (sz < MINSIZE)
        sz = MINSIZE;
    _buf = alloc (sz);
    _len = sz;
    _rptr = _wptr = 0;
    _ralignbase = _walignbase = 0;
    _readonly = 0;
}

CORBA::Buffer::Buffer (const Buffer &b)
{
    _buf = alloc (b._len);
    memcpy (_buf, b._buf, b._len);
    _len = b._len;
    _rptr = b._rptr;
    _wptr = b._wptr;
    _ralignbase = b._ralignbase;
    _walignbase = b._walignbase;
    _readonly = 0;
}

CORBA::Buffer::~Buffer ()
{
    if (!_readonly)
        free (_buf);
}

CORBA::Buffer &
CORBA::Buffer::operator= (const Buffer &b)
{
    if (this != &b) {
        ((void) ((!_readonly && !b._readonly) ? 0 : (__assert_fail ("!_readonly && !b._readonly", "buffer.cc", 74, __PRETTY_FUNCTION__), 0)));
        free (_buf);
        _buf = alloc (b._len);
        memcpy (_buf, b._buf, b._len);
        _len = b._len;
        _rptr = b._rptr;
        _wptr = b._wptr;
        _ralignbase = b._ralignbase;
        _walignbase = b._walignbase;
    }
    return *this;
}

CORBA::Boolean
CORBA::Buffer::operator== (const Buffer &b)
{
    ((void) ((!_readonly && !b._readonly) ? 0 : (__assert_fail ("!_readonly && !b._readonly", "buffer.cc", 90, __PRETTY_FUNCTION__), 0)));
    return length() == b.length() && !memcmp (data(), b.data(), length());
}

CORBA::Octet *
CORBA::Buffer::alloc (ULong sz)
{
    Octet *b = (Octet *)::malloc (sz);
    ((void) ((b) ? 0 : (__assert_fail ("b", "buffer.cc", 98, __PRETTY_FUNCTION__), 0)));
    return b;
}

CORBA::Octet *
CORBA::Buffer::realloc (Octet *b, ULong osz, ULong nsz)
{
    Octet *nb = (Octet *)::realloc ((void *)b, nsz);
    ((void) ((nb) ? 0 : (__assert_fail ("nb", "buffer.cc", 106, __PRETTY_FUNCTION__), 0)));
    return nb;
}

void
CORBA::Buffer::free (Octet *b)
{
    ::free ((void *)b);
}

void
CORBA::Buffer::reset (ULong sz)
{
    _rptr = 0;
    _ralignbase = _walignbase = 0;
    if (!_readonly) {
        _wptr = 0;
        if (sz < MINSIZE)
            sz = MINSIZE;
        if (_len < sz) {
            free (_buf);
            _buf = alloc (sz);
            _len = sz;
        }
    }
}

void
CORBA::Buffer::resize (ULong needed)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 136, __PRETTY_FUNCTION__), 0)));
    if (_wptr + needed > _len) {
        ULong nlen = (_len < RESIZE_THRESH)
            ? (2*_len)
            : (_len + RESIZE_INCREMENT);
        if (_wptr + needed > nlen)
            nlen = _wptr + needed;
        _buf = realloc (_buf, _len, nlen);
        _len = nlen;
    }
}

CORBA::Boolean
CORBA::Buffer::ralign (ULong modulo)
{
    ((void) ((modulo >= 1) ? 0 : (__assert_fail ("modulo >= 1", "buffer.cc", 151, __PRETTY_FUNCTION__), 0)));
    ((void) ((_rptr >= _ralignbase) ? 0 : (__assert_fail ("_rptr >= _ralignbase", "buffer.cc", 152, __PRETTY_FUNCTION__), 0)));
    ULong r = (_rptr - _ralignbase) + modulo - 1;
    r -= r % modulo;
    r += _ralignbase;
    if (r > _wptr)
        return 0;
    _rptr = r;
    return 1;
}

CORBA::Boolean
CORBA::Buffer::peek (void *b, ULong blen)
{
    if (_wptr - _rptr < blen)
        return 0;
    memcpy (b, &_buf[_rptr], blen);
    return 1;
}

CORBA::Boolean
CORBA::Buffer::peek (Octet &o)
{
    if (_wptr == _rptr)
        return 0;
    o = _buf[_rptr];
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get (Octet &o)
{
    if (_wptr == _rptr)
        return 0;
    o = _buf[_rptr++];
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get (void *b, ULong l)
{
    if (_wptr - _rptr < l)
        return 0;
    memcpy (b, &_buf[_rptr], l);
    _rptr += l;
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get1 (void *p)
{
    if (_wptr == _rptr)
        return 0;
    *(Octet *)p = _buf[_rptr++];
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get2 (void *p)
{
    ((void) ((_rptr >= _ralignbase) ? 0 : (__assert_fail ("_rptr >= _ralignbase", "buffer.cc", 211, __PRETTY_FUNCTION__), 0)));
    ULong r = ((_rptr - _ralignbase + 1) & ~1L) + _ralignbase;
    if (r+2 > _wptr)
        return 0;
    _rptr = r;

    if (!((_rptr | (long)p)&1)) {
        *(CORBA::Short *)p = (CORBA::Short &)_buf[_rptr];
        _rptr += 2;
    } else {
        *((Octet * &)p)++ = _buf[_rptr++];
        *(Octet *)p = _buf[_rptr++];
    }
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get4 (void *p)
{
    ((void) ((_rptr >= _ralignbase) ? 0 : (__assert_fail ("_rptr >= _ralignbase", "buffer.cc", 230, __PRETTY_FUNCTION__), 0)));
    ULong r = ((_rptr - _ralignbase + 3) & ~3L) + _ralignbase;
    if (r+4 > _wptr)
        return 0;
    _rptr = r;
    if (!((_rptr | (long)p)&3)) {
        *(CORBA::Long *)p = (CORBA::Long &)_buf[_rptr];
        _rptr += 4;
    } else {
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *(Octet *)p = _buf[_rptr++];
    }
    return 1;
}

CORBA::Boolean
CORBA::Buffer::get8 (void *p)
{
    ((void) ((_rptr >= _ralignbase) ? 0 : (__assert_fail ("_rptr >= _ralignbase", "buffer.cc", 250, __PRETTY_FUNCTION__), 0)));
    ULong r = ((_rptr - _ralignbase + 7) & ~7L) + _ralignbase;
    if (r+8 > _wptr)
        return 0;
    _rptr = r;
    if (!((_rptr | (long)p)&7)) {
        *(CORBA::LongLong *)p = (CORBA::LongLong &)_buf[_rptr];
        _rptr += 8;
    } else {
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *(Octet *)p = _buf[_rptr++];
    }
    return 1;
}


CORBA::Boolean
CORBA::Buffer::get16 (void *p)
{
    ((void) ((_rptr >= _ralignbase) ? 0 : (__assert_fail ("_rptr >= _ralignbase", "buffer.cc", 275, __PRETTY_FUNCTION__), 0)));
    ULong r = ((_rptr - _ralignbase + 7) & ~7L) + _ralignbase;
    if (r+16 > _wptr)
        return 0;
    _rptr = r;
    if (!((_rptr | (long)p)&7)) {
        *((CORBA::LongLong * &)p)++ = (CORBA::LongLong &)_buf[_rptr];
        _rptr += 8;
        *(CORBA::LongLong *)p = (CORBA::LongLong &)_buf[_rptr];
        _rptr += 8;
    } else {
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *((Octet * &)p)++ = _buf[_rptr++];
        *(Octet *)p = _buf[_rptr++];
    }
    return 1;
}

void
CORBA::Buffer::walign (ULong modulo)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 309, __PRETTY_FUNCTION__), 0)));
    ((void) ((modulo >= 1) ? 0 : (__assert_fail ("modulo >= 1", "buffer.cc", 310, __PRETTY_FUNCTION__), 0)));
    ((void) ((_wptr >= _walignbase) ? 0 : (__assert_fail ("_wptr >= _walignbase", "buffer.cc", 311, __PRETTY_FUNCTION__), 0)));
    ULong w = (_wptr - _walignbase) + modulo - 1;
    w -= w % modulo;
    w += _walignbase;
    resize (w - _wptr);
    while (_wptr < w)
        _buf[_wptr++] = 0;
}

void
CORBA::Buffer::replace (const void *o, ULong blen)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 323, __PRETTY_FUNCTION__), 0)));
    reset (blen);
    memcpy (&_buf[_wptr], o, blen);
    _wptr += blen;
}

void
CORBA::Buffer::replace (Octet o)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 332, __PRETTY_FUNCTION__), 0)));
    reset (1);
    _buf[_wptr++] = o;
}

void
CORBA::Buffer::put (const void *o, ULong l)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 340, __PRETTY_FUNCTION__), 0)));
    if (_wptr + l > _len)
        resize (l);
    memcpy (&_buf[_wptr], o, l);
    _wptr += l;
}

void
CORBA::Buffer::put (Octet o)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 350, __PRETTY_FUNCTION__), 0)));
    if (_wptr + 1 > _len)
        resize (1);
    _buf[_wptr++] = o;
}

void
CORBA::Buffer::put1 (const void *p)
{
    ((void) ((!_readonly) ? 0 : (__assert_fail ("!_readonly", "buffer.cc", 359, __PRETTY_FUNCTION__), 0)));
    if (_wptr == _len)
        resize (1);
    _buf[_wptr++] = *(const Octet *)p;
}

void
CORBA::Buffer::put2 (const void *p)
{
    ((void) ((!_readonly && _wptr >= _walignbase) ? 0 : (__assert_fail ("!_readonly && _wptr >= _walignbase", "buffer.cc", 368, __PRETTY_FUNCTION__), 0)));
    if (_wptr+3 > _len)
        resize (3);
    CORBA::Octet *b = _buf + _wptr;
    if ((_wptr - _walignbase) & 1L)
        *b++ = 0;
    if (!(((long)b | (long)p)&1)) {
        *((CORBA::Short *&)b)++ = *(const CORBA::Short *)p;
    } else {
        *b++ = *((const Octet * &)p)++;
        *b++ = *(const Octet *)p;
    }
    _wptr = b - _buf;
}

void
CORBA::Buffer::put4 (const void *p)
{
    ((void) ((!_readonly && _wptr >= _walignbase) ? 0 : (__assert_fail ("!_readonly && _wptr >= _walignbase", "buffer.cc", 386, __PRETTY_FUNCTION__), 0)));
    if (_wptr+7 > _len)
        resize (7);
    CORBA::Octet *b = _buf + _wptr;
    switch ((_wptr - _walignbase) & 3L) {
    case 1: *b++ = 0;
    case 2: *b++ = 0;
    case 3: *b++ = 0;
    }
    if (!(((long)b | (long)p)&3)) {
        *((CORBA::Long * &)b)++ = *(const CORBA::Long *)p;
    } else {
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *(const Octet *)p;
    }
    _wptr = b - _buf;
}

void
CORBA::Buffer::put8 (const void *p)
{
    ((void) ((!_readonly && _wptr >= _walignbase) ? 0 : (__assert_fail ("!_readonly && _wptr >= _walignbase", "buffer.cc", 409, __PRETTY_FUNCTION__), 0)));
    if (_wptr+15 > _len)
        resize (15);
    CORBA::Octet *b = _buf + _wptr;
    switch ((_wptr - _walignbase) & 7L) {
    case 1: *b++ = 0;
    case 2: *b++ = 0;
    case 3: *b++ = 0;
    case 4: *b++ = 0;
    case 5: *b++ = 0;
    case 6: *b++ = 0;
    case 7: *b++ = 0;
    }
    if (!(((long)b | (long)p)&7)) {
        *((CORBA::LongLong *&)b)++ = *(const CORBA::LongLong *)p;
    } else {
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *(const Octet *)p;
    }
    _wptr = b - _buf;
}


void
CORBA::Buffer::put16 (const void *p)
{
    ((void) ((!_readonly && _wptr >= _walignbase) ? 0 : (__assert_fail ("!_readonly && _wptr >= _walignbase", "buffer.cc", 441, __PRETTY_FUNCTION__), 0)));
    if (_wptr+23 > _len)
        resize (23);
    CORBA::Octet *b = _buf + _wptr;
    switch ((_wptr - _walignbase) & 7L) {
    case 1: *b++ = 0;
    case 2: *b++ = 0;
    case 3: *b++ = 0;
    case 4: *b++ = 0;
    case 5: *b++ = 0;
    case 6: *b++ = 0;
    case 7: *b++ = 0;
    }
    if (!(((long)b | (long)p)&7)) {
        *((CORBA::LongLong *&)b)++ = *((const CORBA::LongLong * &)p)++;
        *((CORBA::LongLong *&)b)++ = *(const CORBA::LongLong *)p;
    } else {
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *((const Octet * &)p)++;
        *b++ = *(const Octet *)p;
    }
    _wptr = b - _buf;
}

void
CORBA::Buffer::dump (const char * desc, ostream &o) const
{
  CORBA::ULong i=_rptr, j;
  char temp[256];
  int l=0;

  while (i < _wptr) {
    sprintf (temp, "%10s  ", (i==_rptr) ? desc : "");
    o << temp;

    for (j=0; j<16 && i+j<_wptr; j++) {
      sprintf (temp, "%02x ", _buf[i+j]);
      o << temp;
    }

    for (; j<16; j++) {
      o << "   ";
    }

    o << " ";

    for (j=0; j<16 && i+j<_wptr; j++) {



      if ((_buf[i+j] >= 0040 && _buf[i+j] <= 0176) ||
          (_buf[i+j] >= 0220 && _buf[i+j] != 0231 && _buf[i+j] != 0234)) {
        temp[j] = _buf[i+j];
      }
      else {
        temp[j] = '.';
      }
    }

    temp[j] = '\0';
    o << temp << endl;

    i += j;

    if (++l == 16 && i < _wptr) {
      o << endl;
      l = 0;
    }
  }
}
# 7 "orb_all.cc" 2
# 1 "codec.cc" 1
# 25 "codec.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "codec.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "codec.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 30 "codec.cc" 2
# 1 "../include/mico/impl.h" 1
# 31 "codec.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 32 "codec.cc" 2
# 1 "../include/mico/util.h" 1
# 33 "codec.cc" 2




CORBA::DataEncoder::DataEncoder ()
{
    buf = new Buffer;
    dofree_buf = 1;
    conv = 0;
    dofree_conv = 0;
    vstate = 0;
    dofree_vstate = 0;
}

CORBA::DataEncoder::DataEncoder (Buffer *b, Boolean dofree_b,
                                 CodeSetCoder *c, Boolean dofree_c,
                                 ValueState *vs, Boolean dofree_vs)
{
    buf = b;
    dofree_buf = dofree_b;
    conv = c;
    dofree_conv = dofree_c;
    vstate = vs;
    dofree_vstate = dofree_vs;
}

CORBA::DataEncoder::~DataEncoder ()
{
    if (dofree_buf)
        delete buf;
    if (dofree_conv && conv)
        delete conv;
    if (dofree_vstate && vstate)
        delete vstate;
}

void
CORBA::DataEncoder::put_buffer (const Buffer &b)
{
    buf->put (b.data(), b.length());
}

void
CORBA::DataEncoder::put_octets (const void *data, ULong len)
{
    buf->put (data, len);
}

void
CORBA::DataEncoder::put_string (const string &s)
{
    put_string (s.c_str());
}

void
CORBA::DataEncoder::put_string_raw (const string &s)
{
    put_string_raw (s.c_str());
}

void
CORBA::DataEncoder::put_context (const Context &ctx, ContextList_ptr clist)
{
    ctx.encode (*this, clist);
}

void
CORBA::DataEncoder::put_principal (const Principal &pr)
{
    pr.encode (*this);
}

void
CORBA::DataEncoder::put_any (const Any &a)
{
    a.encode (*this);
}

void
CORBA::DataEncoder::put_typecode (const TypeCode &t)
{
    t.encode (*this);
}

void
CORBA::DataEncoder::put_ior (const IOR &ior)
{
    ior.encode (*this);
}

void
CORBA::DataEncoder::enumeration (ULong val)
{
    put_ulong (val);
}

void
CORBA::DataEncoder::struct_begin ()
{
}

void
CORBA::DataEncoder::struct_end ()
{
}

void
CORBA::DataEncoder::except_begin (const string &repoid)
{
    put_string (repoid);
}

void
CORBA::DataEncoder::except_end ()
{
}

void
CORBA::DataEncoder::seq_begin (ULong l)
{
    put_ulong (l);
}

void
CORBA::DataEncoder::seq_end ()
{
}

void
CORBA::DataEncoder::encaps_begin (EncapsState &state)
{




    state.align = buffer()->walign_base ();
    state.bo = byteorder();
    state.pos = buffer()->wpos();

    put_ulong (0);

    buffer()->walign_base (buffer()->wpos());

    put_octet (byteorder() == CORBA::LittleEndian ? 1 : 0);
}

void
CORBA::DataEncoder::encaps_end (EncapsState &state)
{
    byteorder (state.bo);
    buffer()->walign_base (state.align);

    ULong end = buffer()->wpos();

    buffer()->wseek_beg (state.pos);
    put_ulong (0);

    ULong data_start = buffer()->wpos();
    buffer()->wseek_beg (state.pos);
    put_ulong (end-data_start);

    buffer()->wseek_beg (end);
}

void
CORBA::DataEncoder::delayed_seq_begin (DelayedSeqState &state)
{
    state.pos = buffer()->wpos();
    put_ulong (0);
}

void
CORBA::DataEncoder::delayed_seq_end (DelayedSeqState &state, ULong l)
{
    ULong pos = buffer()->wpos();
    buffer()->wseek_beg (state.pos);
    put_ulong (l);
    buffer()->wseek_beg (pos);
}

void
CORBA::DataEncoder::union_begin ()
{
}

void
CORBA::DataEncoder::union_end ()
{
}

void
CORBA::DataEncoder::arr_begin ()
{
}

void
CORBA::DataEncoder::arr_end ()
{
}

void
CORBA::DataEncoder::value_begin (const string &url,
                                 const vector<string> &repoids,
                                 Boolean chunked,
                                 Long &value_id)
{
    ((void) ((vstate) ? 0 : (__assert_fail ("vstate", "codec.cc", 239, __PRETTY_FUNCTION__), 0)));
    value_begin (url, repoids, chunked, value_id, *vstate);
}

void
CORBA::DataEncoder::value_begin (const string &url,
                                 const vector<string> &repoids,
                                 Boolean chunked,
                                 Long &value_id,
                                 ValueState &state)
{
    if (state.chunk_level <= state.nesting_level && state.tag_pos >= 0) {

        if (state.tag_pos + sizeof(Long) == buf->wpos()) {

            buf->wseek_beg (state.tag_pos);
        } else {

            Long wpos = buf->wpos();
            buf->wseek_beg (state.tag_pos);
            put_long (wpos - state.tag_pos - sizeof (Long));
            buf->wseek_beg (wpos);
        }
    }

    state.nesting_level += 1;
    if (chunked && state.chunk_level > state.nesting_level)
        state.chunk_level = state.nesting_level;

    Long value_tag = 0x7fffff00;

    if (url.length() > 0)

        value_tag |= 0x01;

    if (repoids.size() == 1) {

        value_tag |= 0x02;
    } else if (repoids.size() > 1) {

        value_tag |= 0x06;
    }

    if (state.chunk_level <= state.nesting_level)

        value_tag |= 0x08;

    put_long (value_tag);


    value_id = buf->wpos() - sizeof(Long) + 1;

    if (url.length() > 0)
        put_string (url);

    if (repoids.size() == 1) {
        put_string (repoids[0]);
    } else if (repoids.size() > 1) {
        seq_begin (repoids.size());
        for (mico_vec_size_type i = 0; i < repoids.size(); ++i)
            put_string (repoids[i]);
        seq_end();
    }

    if (state.chunk_level <= state.nesting_level) {

        put_long (0);
        state.tag_pos = buf->wpos() - sizeof (Long);
    }
}

void
CORBA::DataEncoder::value_end (Long value_id)
{
    ((void) ((vstate) ? 0 : (__assert_fail ("vstate", "codec.cc", 313, __PRETTY_FUNCTION__), 0)));
    value_end (value_id, *vstate);
}

void
CORBA::DataEncoder::value_end (Long value_id, ValueState &state)
{
    ((void) ((state.nesting_level > 0) ? 0 : (__assert_fail ("state.nesting_level > 0", "codec.cc", 320, __PRETTY_FUNCTION__), 0)));

    if (!(state.chunk_level <= state.nesting_level)) {

        state.nesting_level -= 1;
        return;
    }

    if (state.tag_pos >= 0) {

        if (state.tag_pos + sizeof(Long) == buf->wpos()) {

            buf->wseek_beg (state.tag_pos);
        } else {

            Long wpos = buf->wpos();
            buf->wseek_beg (state.tag_pos);
            put_long (wpos - state.tag_pos - sizeof (Long));
            buf->wseek_beg (wpos);
        }
    }


    put_long (-state.nesting_level);

    state.nesting_level -= 1;
    if (state.nesting_level > 0 &&
        state.chunk_level <= state.nesting_level) {

        put_long (0);
        state.tag_pos = buf->wpos() - sizeof (Long);
    } else {

        state.chunk_level = 0x7fffffff;
        state.tag_pos = -1;
    }
}

void
CORBA::DataEncoder::value_ref (Long value_id)
{
    if (value_id == 0) {

        put_long (0);
    } else {

        put_long (0xffffffff);

        put_long (value_id - 1 - buf->wpos());
    }
}

void
CORBA::DataEncoder::buffer (Buffer *b, Boolean release)
{
    if (dofree_buf)
        delete buf;
    buf = b;
    dofree_buf = release;
}

void
CORBA::DataEncoder::converter (CodeSetCoder *c, Boolean release)
{
    if (dofree_conv && conv)
        delete conv;
    conv = c;
    dofree_conv = release;
}

void
CORBA::DataEncoder::valuestate (ValueState *vs, Boolean release)
{
    if (dofree_vstate && vstate)
        delete vstate;
    vstate = vs;
    dofree_vstate = release;
}

CORBA::ByteOrder
CORBA::DataEncoder::byteorder () const
{



    return CORBA::LittleEndian;

}

void
CORBA::DataEncoder::byteorder (CORBA::ByteOrder bo)
{
    ((void) ((bo == byteorder()) ? 0 : (__assert_fail ("bo == byteorder()", "codec.cc", 412, __PRETTY_FUNCTION__), 0)));
}





CORBA::DataDecoder::DataDecoder (Buffer *b, Boolean dofree_b,
                                 CodeSetCoder *c, Boolean dofree_c,
                                 ValueState *vs, Boolean dofree_vs)
{
    buf = b;
    dofree_buf = dofree_b;
    conv = c;
    dofree_conv = dofree_c;
    vstate = vs;
    dofree_vstate = dofree_vs;
}

CORBA::DataDecoder::~DataDecoder ()
{
    if (dofree_buf)
        delete buf;
    if (dofree_conv && conv)
        delete conv;
    if (dofree_vstate && vstate)
        delete vstate;
}

CORBA::Boolean
CORBA::DataDecoder::get_octets (void *data, ULong len)
{
    return buf->get (data, len);
}

CORBA::Boolean
CORBA::DataDecoder::get_string_stl (string &str)
{
    char *s;
    if (!get_string (s))
        return 0;
    str = s;
    CORBA::string_free (s);
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::get_string_raw_stl (string &str)
{
    char *s;
    if (!get_string_raw (s))
        return 0;
    str = s;
    CORBA::string_free (s);
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::get_context (Context &ctx)
{
    return ctx.decode (*this);
}

CORBA::Boolean
CORBA::DataDecoder::get_principal (Principal &pr)
{
    return pr.decode (*this);
}

CORBA::Boolean
CORBA::DataDecoder::get_any (Any &a)
{
    return a.decode (*this);
}

CORBA::Boolean
CORBA::DataDecoder::get_typecode (TypeCode &t)
{
    return t.decode (*this);
}

CORBA::Boolean
CORBA::DataDecoder::get_ior (IOR &ior)
{
    return ior.decode (*this);
}

CORBA::Boolean
CORBA::DataDecoder::enumeration (ULong &val)
{
    return get_ulong (val);
}

CORBA::Boolean
CORBA::DataDecoder::struct_begin ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::struct_end ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::except_begin (string &repoid)
{
    return get_string_stl (repoid);
}

CORBA::Boolean
CORBA::DataDecoder::except_end ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::seq_begin (ULong &l)
{
    return get_ulong (l);
}

CORBA::Boolean
CORBA::DataDecoder::seq_end ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::encaps_begin (EncapsState &state, ULong &len)
{




    state.align = buffer()->ralign_base();
    state.bo = byteorder();

    if (!get_ulong (len))
        return 0;

    buffer()->ralign_base (buffer()->rpos());

    if (len == 0) {


        return 1;
    }
    --len;

    Octet bo;
    if (!get_octet (bo))
        return 0;
    byteorder (bo == 0 ? CORBA::BigEndian : CORBA::LittleEndian);
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::encaps_end (EncapsState &state)
{
    byteorder (state.bo);
    buffer()->ralign_base (state.align);
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::union_begin ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::union_end ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::arr_begin ()
{
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::arr_end ()
{
    return 1;
}


CORBA::Boolean
CORBA::DataDecoder::get_indirect_string (string &s)
{
    Long tag, rpos = buf->rpos();

    if (!get_long (tag))
        return 0;
    if (tag == 0xffffffff) {

        Long indir;
        rpos = buf->rpos();
        if (!get_long (indir))
            return 0;
        indir += rpos;
        rpos = buf->rpos();
        if (!buf->rseek_beg (indir))
            return 0;
        if (!get_string_stl (s))
            return 0;
        buf->rseek_beg (rpos);
    } else {

        buf->rseek_beg (rpos);
        if (!get_string_stl (s))
            return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::get_indirect_string_seq (vector<string> &v)
{
    Long tag, rpos = buf->rpos();

    if (!get_long (tag))
        return 0;
    if (tag == 0xffffffff) {

        Long indir;
        rpos = buf->rpos();
        if (!get_long (indir))
            return 0;
        indir += rpos;
        rpos = buf->rpos();
        if (!buf->rseek_beg (indir))
            return 0;

        ULong len;
        string s;
        if (!seq_begin (len))
            return 0;
        for (ULong i = 0; i < len; ++i) {
            if (!get_string_stl (s))
                return 0;
            v.push_back (s);
        }
        if (!seq_end ())
            return 0;
        buf->rseek_beg (rpos);
    } else {

        buf->rseek_beg (rpos);

        ULong len;
        string s;
        if (!seq_begin (len))
            return 0;
        for (ULong i = 0; i < len; ++i) {
            if (!get_string_stl (s))
                return 0;
            v.push_back (s);
        }
        if (!seq_end ())
            return 0;
    }
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::value_begin (string &url,
                                 vector<string> &repoids,
                                 Long &value_id,
                                 Boolean &is_ref)
{
    ((void) ((vstate) ? 0 : (__assert_fail ("vstate", "codec.cc", 687, __PRETTY_FUNCTION__), 0)));
    return value_begin (url, repoids, value_id, is_ref, *vstate);
}

CORBA::Boolean
CORBA::DataDecoder::value_begin (string &url,
                                 vector<string> &repoids,
                                 Long &value_id,
                                 Boolean &is_ref,
                                 ValueState &state)
{
    Long value_tag;

    if (!get_long (value_tag))
        return 0;

    if (value_tag == 0xffffffff) {

        Long indir, rpos = buf->rpos();
        if (!get_long (indir))
            return 0;


        value_id = rpos + indir + 1;

        MapIdState::iterator i = state.skipped.find (value_id);
        if (i != state.skipped.end() && (*i).second.saved_pos < 0) {



            ValueState1 tmp_state = state.s;
            tmp_state.saved_pos = buf->rpos();

            state.s = (*i).second;
            (*i).second = tmp_state;

            buf->rseek_beg (value_id-1);
            return value_begin (url, repoids, value_id, is_ref, state);
        } else {

            is_ref = 1;
            return 1;
        }
    }
    if (value_tag == 0) {

        value_id = 0;
        is_ref = 1;
        return 1;
    }
    if (!(0x7fffff00 <= value_tag && value_tag <= 0x7fffffff)) {
      if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
        MICO::Logger::Stream (MICO::Logger::Info)
          << "Info: DataDecoder::value_begin(): bad tag: "
          << "0x" << hex << value_tag << endl;
      }
      return 0;
    }



    value_id = buf->rpos() - sizeof (Long) + 1;
    is_ref = 0;

    if (value_tag & 0x01) {

        if (!get_indirect_string (url))
            return 0;
    }

    repoids.erase (repoids.begin(), repoids.end());
    if ((value_tag & 0x06) == 0x02) {

        string s;
        if (!get_indirect_string (s))
            return 0;
        repoids.push_back (s);
    } else if ((value_tag & 0x06) == 0x06) {

        if (!get_indirect_string_seq (repoids))
            return 0;
    }

    state.s.nesting_level += 1;

    if (value_tag & 0x08) {

        if (state.s.chunk_level > state.s.nesting_level)
            state.s.chunk_level = state.s.nesting_level;
    }

    if (state.s.chunk_level <= state.s.nesting_level) {

        state.s.data_nesting_level += 1;


        Long tag, rpos = buf->rpos();

        if (!get_long (tag))
            return 0;

        if (0 < tag && tag < 0x7fffff00) {

            rpos = buf->rpos();




            if (!buf->rseek_rel (tag))
                return 0;
            if (!get_long (tag))
                return 0;
            ((void) ((!(0 < tag && tag < 0x7fffff00)) ? 0 : (__assert_fail ("!(0 < tag && tag < 0x7fffff00)", "codec.cc", 799, __PRETTY_FUNCTION__), 0)));
        }
        buf->rseek_beg (rpos);
    }
    return 1;
}

CORBA::Boolean
CORBA::DataDecoder::value_end (Long finished_value_id)
{
    ((void) ((vstate) ? 0 : (__assert_fail ("vstate", "codec.cc", 809, __PRETTY_FUNCTION__), 0)));
    return value_end (finished_value_id, *vstate);
}

CORBA::Boolean
CORBA::DataDecoder::value_end (Long finished_value_id, ValueState &state)
{



    ((void) ((state.s.nesting_level > 0) ? 0 : (__assert_fail ("state.s.nesting_level > 0", "codec.cc", 819, __PRETTY_FUNCTION__), 0)));

    MapIdState::iterator i = state.skipped.find (finished_value_id);
    if (i != state.skipped.end() && (*i).second.saved_pos >= 0) {


        buf->rseek_beg ((*i).second.saved_pos);

        state.s = (*i).second;
        state.s.saved_pos = -1;

        state.skipped.erase (i);
        return 1;
    }

    if (!(state.s.chunk_level <= state.s.nesting_level)) {

        state.s.nesting_level -= 1;
        return 1;
    }

    if (state.s.data_nesting_level < state.s.nesting_level) {

        state.s.nesting_level -= 1;
        return 1;
    }


    while (state.s.data_nesting_level >= state.s.nesting_level) {
        Long tag, rpos = buf->rpos();
        if (!get_long (tag))
            return 0;
        if (0 < tag && tag < 0x7fffff00) {

            if (!buf->rseek_rel (tag))
                return 0;
        } else if (tag < 0) {

            if (state.s.data_nesting_level > -tag-1) {
                state.s.data_nesting_level = -tag-1;
            } else {
              if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
                MICO::Logger::Stream (MICO::Logger::Info)
                    << "Info: DataDecoder::value_end(): bad end tag: "
                    << tag << " (ignored)" << endl;
              }
            }
        } else {

            buf->rseek_beg (rpos);

            string url;
            vector<string> repoids;
            Long value_id;
            Boolean is_ref;
            ValueState1 saved_state = state.s;

            if (!value_begin (url, repoids, value_id, is_ref, state))
                return 0;
            if (!is_ref) {
                if (!value_end (value_id, state))
                    return 0;





                saved_state.saved_pos = -1;
                state.skipped[value_id] = saved_state;
            }
        }
    }
    state.s.nesting_level -= 1;

    while (state.s.data_nesting_level > 0 &&
           state.s.chunk_level <= state.s.data_nesting_level) {

        Long tag, rpos = buf->rpos();
        if (!get_long (tag))
            return 0;

        if (tag < 0) {

            if (state.s.data_nesting_level > -tag-1) {
                state.s.data_nesting_level = -tag-1;
            } else {
              if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
                MICO::Logger::Stream (MICO::Logger::Info)
                  << "Info: DataDecoder::value_end(): bad end tag: "
                  << tag << " (ignored)" << endl;
              }
            }
        } else {

            buf->rseek_beg (rpos);
            break;
        }
    }
    if (state.s.data_nesting_level > 0 &&
        state.s.chunk_level <= state.s.data_nesting_level) {

        Long tag, rpos = buf->rpos();

        if (!get_long (tag))
            return 0;

        if (0 < tag && tag < 0x7fffff00) {

            rpos = buf->rpos();




            if (!buf->rseek_rel (tag))
                return 0;
            if (!get_long (tag))
                return 0;
            ((void) ((!(0 < tag && tag < 0x7fffff00)) ? 0 : (__assert_fail ("!(0 < tag && tag < 0x7fffff00)", "codec.cc", 936, __PRETTY_FUNCTION__), 0)));
        }
        buf->rseek_beg (rpos);
    } else {

        state.s.chunk_level = 0x7fffffff;
    }
    return 1;
}

void
CORBA::DataDecoder::buffer (Buffer *b, Boolean release)
{
    if (dofree_buf)
        delete buf;
    buf = b;
    dofree_buf = release;
}

void
CORBA::DataDecoder::converter (CodeSetCoder *c, Boolean release)
{
    if (dofree_conv && conv)
        delete conv;
    conv = c;
    dofree_conv = release;
}

void
CORBA::DataDecoder::valuestate (ValueState *vs, Boolean release)
{
    if (dofree_vstate && vstate)
        delete vstate;
    vstate = vs;
    dofree_vstate = release;
}

CORBA::ByteOrder
CORBA::DataDecoder::byteorder () const
{



    return CORBA::LittleEndian;

}

void
CORBA::DataDecoder::byteorder (CORBA::ByteOrder bo)
{
    ((void) ((bo == byteorder()) ? 0 : (__assert_fail ("bo == byteorder()", "codec.cc", 986, __PRETTY_FUNCTION__), 0)));
}




static inline void swap2 (void *d, const void *s)
{
    ((CORBA::Octet *)d)[0] = ((CORBA::Octet *)s)[1];
    ((CORBA::Octet *)d)[1] = ((CORBA::Octet *)s)[0];
}

static inline void swap4 (void *d, const void *s)
{
    ((CORBA::Octet *)d)[0] = ((CORBA::Octet *)s)[3];
    ((CORBA::Octet *)d)[1] = ((CORBA::Octet *)s)[2];
    ((CORBA::Octet *)d)[2] = ((CORBA::Octet *)s)[1];
    ((CORBA::Octet *)d)[3] = ((CORBA::Octet *)s)[0];
}

static inline void swap8 (void *d, const void *s)
{
    ((CORBA::Octet *)d)[0] = ((CORBA::Octet *)s)[7];
    ((CORBA::Octet *)d)[1] = ((CORBA::Octet *)s)[6];
    ((CORBA::Octet *)d)[2] = ((CORBA::Octet *)s)[5];
    ((CORBA::Octet *)d)[3] = ((CORBA::Octet *)s)[4];
    ((CORBA::Octet *)d)[4] = ((CORBA::Octet *)s)[3];
    ((CORBA::Octet *)d)[5] = ((CORBA::Octet *)s)[2];
    ((CORBA::Octet *)d)[6] = ((CORBA::Octet *)s)[1];
    ((CORBA::Octet *)d)[7] = ((CORBA::Octet *)s)[0];
}

static inline void swap16 (void *d, const void *s)
{
    ((CORBA::Octet *)d)[0] = ((CORBA::Octet *)s)[15];
    ((CORBA::Octet *)d)[1] = ((CORBA::Octet *)s)[14];
    ((CORBA::Octet *)d)[2] = ((CORBA::Octet *)s)[13];
    ((CORBA::Octet *)d)[3] = ((CORBA::Octet *)s)[12];
    ((CORBA::Octet *)d)[4] = ((CORBA::Octet *)s)[11];
    ((CORBA::Octet *)d)[5] = ((CORBA::Octet *)s)[10];
    ((CORBA::Octet *)d)[6] = ((CORBA::Octet *)s)[9];
    ((CORBA::Octet *)d)[7] = ((CORBA::Octet *)s)[8];
    ((CORBA::Octet *)d)[8] = ((CORBA::Octet *)s)[7];
    ((CORBA::Octet *)d)[9] = ((CORBA::Octet *)s)[6];
    ((CORBA::Octet *)d)[10] = ((CORBA::Octet *)s)[5];
    ((CORBA::Octet *)d)[11] = ((CORBA::Octet *)s)[4];
    ((CORBA::Octet *)d)[12] = ((CORBA::Octet *)s)[3];
    ((CORBA::Octet *)d)[13] = ((CORBA::Octet *)s)[2];
    ((CORBA::Octet *)d)[14] = ((CORBA::Octet *)s)[1];
    ((CORBA::Octet *)d)[15] = ((CORBA::Octet *)s)[0];
}

MICO::CDREncoder::CDREncoder ()
{



    mach_bo = CORBA::LittleEndian;

    data_bo = mach_bo;
}

MICO::CDREncoder::CDREncoder (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                              CORBA::ByteOrder _bo,
                              CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c,
                              ValueState *vs, CORBA::Boolean dofree_vs)
    : CORBA::DataEncoder (b, dofree_b, c, dofree_c,
                          vs, dofree_vs)
{



    mach_bo = CORBA::LittleEndian;

    data_bo = (_bo == CORBA::DefaultEndian) ? mach_bo : _bo;
}

MICO::CDREncoder::~CDREncoder ()
{
}

void
MICO::CDREncoder::put_short (CORBA::Short s)
{
    if (mach_bo == data_bo) {
        buf->put2 (&s);
    } else {
        CORBA::Short s2;
        swap2 (&s2, &s);
        buf->put2 (&s2);
    }
}

void
MICO::CDREncoder::put_ushort (CORBA::UShort us)
{
    if (mach_bo == data_bo) {
        buf->put2 (&us);
    } else {
        CORBA::UShort us2;
        swap2 (&us2, &us);
        buf->put2 (&us2);
    }
}

void
MICO::CDREncoder::put_long (CORBA::Long l)
{
    if (mach_bo == data_bo) {
        buf->put4 (&l);
    } else {
        CORBA::Long l2;
        swap4 (&l2, &l);
        buf->put4 (&l2);
    }
}

void
MICO::CDREncoder::put_longlong (CORBA::LongLong l)
{
    if (mach_bo == data_bo) {
        buf->put8 (&l);
    } else {
        CORBA::LongLong l2;
        swap8 (&l2, &l);
        buf->put8 (&l2);
    }
}

void
MICO::CDREncoder::put_ulong (CORBA::ULong ul)
{
    if (mach_bo == data_bo) {
        buf->put4 (&ul);
    } else {
        CORBA::ULong ul2;
        swap4 (&ul2, &ul);
        buf->put4 (&ul2);
    }
}

void
MICO::CDREncoder::put_ulonglong (CORBA::ULongLong ul)
{
    if (mach_bo == data_bo) {
        buf->put8 (&ul);
    } else {
        CORBA::ULongLong ul2;
        swap8 (&ul2, &ul);
        buf->put8 (&ul2);
    }
}

void
MICO::CDREncoder::put_float (CORBA::Float f)
{

    if (mach_bo == data_bo) {
        buf->put4 (&f);
    } else {
        CORBA::Float f2;
        swap4 (&f2, &f);
        buf->put4 (&f2);
    }
# 1161 "codec.cc"
}

void
MICO::CDREncoder::put_double (CORBA::Double d)
{

    if (mach_bo == data_bo) {
        buf->put8 (&d);
    } else {
        CORBA::Double d2;
        swap8 (&d2, &d);
        buf->put8 (&d2);
    }
# 1185 "codec.cc"
}

void
MICO::CDREncoder::put_longdouble (CORBA::LongDouble d)
{
# 1199 "codec.cc"
    CORBA::Octet b[16];
    mico_ldouble2ieee (b, d);
    if (mach_bo == data_bo) {
        buf->put16 (b);
    } else {
        CORBA::Octet b2[16];
        swap16 (b2, b);
        buf->put16 (b2);
    }

}

void
MICO::CDREncoder::put_char (CORBA::Char c)
{
  if (!conv) {
    buf->put1 (&c);
    return;
  }
  conv->put_char (*this, c);
}

void
MICO::CDREncoder::put_char_raw (CORBA::Char c)
{
    buf->put1 (&c);
}

void
MICO::CDREncoder::put_wchar (CORBA::WChar c)
{
  if (!conv) {
    buf->put (&c, sizeof (CORBA::WChar));
    return;
  }
  conv->put_wchar (*this, c);
}

void
MICO::CDREncoder::put_octet (CORBA::Octet o)
{
    buf->put1 (&o);
}

void
MICO::CDREncoder::put_boolean (CORBA::Boolean b)
{
    buf->put1 (&b);
}

void
MICO::CDREncoder::put_shorts (const CORBA::Short *p, CORBA::ULong l)
{
    buf->walign (2);
    if (mach_bo == data_bo) {
        buf->put (p, 2*l);
    } else {
        buf->resize (2*l);
        CORBA::Short *d = (CORBA::Short *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap2 (d, p);
        buf->wseek_rel (2*l);
    }
}

void
MICO::CDREncoder::put_ushorts (const CORBA::UShort *p, CORBA::ULong l)
{
    buf->walign (2);
    if (mach_bo == data_bo) {
        buf->put (p, 2*l);
    } else {
        buf->resize (2*l);
        CORBA::UShort *d = (CORBA::UShort *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap2 (d, p);
        buf->wseek_rel (2*l);
    }
}

void
MICO::CDREncoder::put_longs (const CORBA::Long *p, CORBA::ULong l)
{
    buf->walign (4);
    if (mach_bo == data_bo) {
        buf->put (p, 4*l);
    } else {
        buf->resize (4*l);
        CORBA::Long *d = (CORBA::Long *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap4 (d, p);
        buf->wseek_rel (4*l);
    }
}

void
MICO::CDREncoder::put_longlongs (const CORBA::LongLong *p, CORBA::ULong l)
{
    buf->walign (8);
    if (mach_bo == data_bo) {
        buf->put (p, 8*l);
    } else {
        buf->resize (8*l);
        CORBA::LongLong *d = (CORBA::LongLong *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap8 (d, p);
        buf->wseek_rel (8*l);
    }
}

void
MICO::CDREncoder::put_ulongs (const CORBA::ULong *p, CORBA::ULong l)
{
    buf->walign (4);
    if (mach_bo == data_bo) {
        buf->put (p, 4*l);
    } else {
        buf->resize (4*l);
        CORBA::ULong *d = (CORBA::ULong *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap4 (d, p);
        buf->wseek_rel (4*l);
    }
}

void
MICO::CDREncoder::put_ulonglongs (const CORBA::ULongLong *p, CORBA::ULong l)
{
    buf->walign (8);
    if (mach_bo == data_bo) {
        buf->put (p, 8*l);
    } else {
        buf->resize (8*l);
        CORBA::ULongLong *d = (CORBA::ULongLong *)buf->wdata();
        for (CORBA::Long i = l; --i >= 0; ++d, ++p)
            swap8 (d, p);
        buf->wseek_rel (8*l);
    }
}

void
MICO::CDREncoder::put_floats (const CORBA::Float *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p)
        put_float (*p);
}

void
MICO::CDREncoder::put_doubles (const CORBA::Double *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p)
        put_double (*p);
}

void
MICO::CDREncoder::put_longdoubles (const CORBA::LongDouble *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p)
        put_longdouble (*p);
}

void
MICO::CDREncoder::put_chars (const CORBA::Char *p, CORBA::ULong l)
{
  if (!conv) {
    buf->put (p, l);
    return;
  }
  conv->put_chars (*this, p, l);
}

void
MICO::CDREncoder::put_chars_raw (const CORBA::Char *p, CORBA::ULong l)
{
    buf->put (p, l);
}

void
MICO::CDREncoder::put_wchars (const CORBA::WChar *p, CORBA::ULong l)
{
  if (!conv) {
    buf->put (p, l * sizeof (CORBA::WChar));
    return;
  }
  conv->put_wchars (*this, p, l);
}

void
MICO::CDREncoder::put_booleans (const CORBA::Boolean *p, CORBA::ULong l)
{
    buf->put (p, l);
}

void
MICO::CDREncoder::put_string (const char *s)
{
  if (!conv) {
    CORBA::ULong len = strlen (s) + 1;
    put_ulong (len);
    put_octets (s, len);
    return;
  }

  conv->put_string (*this, s, 0);
}

void
MICO::CDREncoder::put_string_raw (const char *s)
{
    CORBA::ULong len = strlen (s) + 1;
    put_ulong (len);
    put_octets (s, len);
}

void
MICO::CDREncoder::put_wstring (const wchar_t *s)
{
    if (!conv) {
      CORBA::ULong len = xwcslen (s) + 1;
      put_ulong (len);
      buf->put (s, len * sizeof (wchar_t));
      return;
    }

    conv->put_wstring (*this, s, 0);
}

void
MICO::CDREncoder::put_fixed (const FixedBase::FixedValue &value,
                             CORBA::UShort digits,
                             CORBA::Short scale)
{
    ((void) ((value.length() == (CORBA::ULong)digits+1) ? 0 : (__assert_fail ("value.length() == (CORBA::ULong)digits+1", "codec.cc", 1431, __PRETTY_FUNCTION__), 0)));

    int s = 0, n = value.length();

    if (n == 1) {
        put_octet ((CORBA::Octet)value[0] ? 0xd : 0xc);
        return;
    }
    if ((n & 1)) {
        put_octet ((CORBA::Octet)value[0]);
        s = 1;
    }
    for (int i = s; i < n-2; i+=2)
        put_octet (((CORBA::Octet)value[i] << 4) | (CORBA::Octet)value[i+1]);
    put_octet (((CORBA::Octet)value[n-2] << 4) |
               ((CORBA::Octet)value[n-1] ? 0xd : 0xc));
}

CORBA::DataEncoder *
MICO::CDREncoder::clone () const
{
    return new CDREncoder (new CORBA::Buffer (*buf), 1, data_bo,
                           (conv ? conv->clone() : 0), 1,
                           (vstate ? new ValueState (*vstate) : 0), 1);
}

CORBA::DataEncoder *
MICO::CDREncoder::clone (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                         CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c,
                         ValueState *vs, CORBA::Boolean dofree_vs) const
{
    return new CDREncoder (b, dofree_b, data_bo, c, dofree_c,
                           vs, dofree_vs);
}

CORBA::DataDecoder *
MICO::CDREncoder::decoder () const
{
    return new CDRDecoder (new CORBA::Buffer (*buf), 1, data_bo,
                           (conv ? conv->clone() : 0), 1,
                           0, 1);
}

CORBA::DataDecoder *
MICO::CDREncoder::decoder (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                           CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c
                           ) const
{
    return new CDRDecoder (b, dofree_b, data_bo, c, dofree_c,
                           0, 1);
}

const char *
MICO::CDREncoder::type () const
{
    return "cdr";
}

CORBA::ByteOrder
MICO::CDREncoder::byteorder () const
{
    return data_bo;
}

void
MICO::CDREncoder::byteorder (CORBA::ByteOrder _bo)
{
    data_bo = _bo;
}

CORBA::ULong
MICO::CDREncoder::max_alignment () const
{
    return 8;
}





MICO::CDRDecoder::CDRDecoder ()
    : CORBA::DataDecoder (new CORBA::Buffer, 1)
{



    mach_bo = CORBA::LittleEndian;

    data_bo = mach_bo;
}

MICO::CDRDecoder::CDRDecoder (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                              CORBA::ByteOrder _bo,
                              CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c,
                              ValueState *vs, CORBA::Boolean dofree_vs)
    : CORBA::DataDecoder (b, dofree_b, c, dofree_c,
                          vs, dofree_vs)
{



    mach_bo = CORBA::LittleEndian;

    data_bo = (_bo == CORBA::DefaultEndian) ? mach_bo : _bo;
}

MICO::CDRDecoder::~CDRDecoder ()
{
}

CORBA::Boolean
MICO::CDRDecoder::get_short (CORBA::Short &s)
{
    if (data_bo == mach_bo)
        return buf->get2 (&s);

    CORBA::Short s2;
    if (!buf->get2 (&s2))
        return 0;
    swap2 (&s, &s2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ushort (CORBA::UShort &us)
{
    if (data_bo == mach_bo)
        return buf->get2 (&us);

    CORBA::UShort us2;
    if (!buf->get2 (&us2))
        return 0;
    swap2 (&us, &us2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_long (CORBA::Long &l)
{
    if (data_bo == mach_bo)
        return buf->get4 (&l);

    CORBA::Long l2;
    if (!buf->get4 (&l2))
        return 0;
    swap4 (&l, &l2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_longlong (CORBA::LongLong &l)
{
    if (data_bo == mach_bo)
        return buf->get8 (&l);

    CORBA::LongLong l2;
    if (!buf->get8 (&l2))
        return 0;
    swap8 (&l, &l2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ulong (CORBA::ULong &ul)
{
    if (data_bo == mach_bo)
        return buf->get4 (&ul);

    CORBA::ULong ul2;
    if (!buf->get4 (&ul2))
        return 0;
    swap4 (&ul, &ul2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ulonglong (CORBA::ULongLong &ul)
{
    if (data_bo == mach_bo)
        return buf->get8 (&ul);

    CORBA::ULongLong ul2;
    if (!buf->get8 (&ul2))
        return 0;
    swap8 (&ul, &ul2);
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_float (CORBA::Float &f)
{

    if (data_bo == mach_bo)
        return buf->get4 (&f);

    CORBA::Float f2;
    if (!buf->get4 (&f2))
        return 0;
    swap4 (&f, &f2);
# 1645 "codec.cc"
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_double (CORBA::Double &d)
{

    if (data_bo == mach_bo)
        return buf->get8 (&d);

    CORBA::Double d2;
    if (!buf->get8 (&d2))
        return 0;
    swap8 (&d, &d2);
# 1674 "codec.cc"
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_longdouble (CORBA::LongDouble &d)
{
# 1689 "codec.cc"
    CORBA::Octet b[16];
    if (data_bo == mach_bo) {
        if (!buf->get16 (b))
            return 0;
        mico_ieee2ldouble (b, d);
        return 1;
    }

    CORBA::Octet b2[16];
    if (!buf->get16 (b2))
        return 0;
    swap16 (&b, &b2);
    mico_ieee2ldouble (b, d);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_char (CORBA::Char &c)
{
  if (!conv) {
    return buf->get1 (&c);
  }

  return conv->get_char (*this, c);
}

CORBA::Boolean
MICO::CDRDecoder::get_char_raw (CORBA::Char &c)
{
    return buf->get1 (&c);
}

CORBA::Boolean
MICO::CDRDecoder::get_wchar (CORBA::WChar &c)
{
  if (!conv) {
    return buf->get (&c, sizeof (CORBA::WChar));
  }

  return conv->get_wchar (*this, c);
}

CORBA::Boolean
MICO::CDRDecoder::get_octet (CORBA::Octet &o)
{
    return buf->get1 (&o);
}

CORBA::Boolean
MICO::CDRDecoder::get_boolean (CORBA::Boolean &b)
{
    return buf->get1 (&b);
}

CORBA::Boolean
MICO::CDRDecoder::get_shorts (CORBA::Short *p, CORBA::ULong l)
{
    if (!buf->ralign (2))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 2*l);

    if (buf->length() < 2*l)
        return 0;

    CORBA::Short *s = (CORBA::Short *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap2 (p, s);
    buf->rseek_rel (2*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ushorts (CORBA::UShort *p, CORBA::ULong l)
{
    if (!buf->ralign (2))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 2*l);

    if (buf->length() < 2*l)
        return 0;

    CORBA::UShort *s = (CORBA::UShort *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap2 (p, s);
    buf->rseek_rel (2*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_longs (CORBA::Long *p, CORBA::ULong l)
{
    if (!buf->ralign (4))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 4*l);

    if (buf->length() < 4*l)
        return 0;

    CORBA::Long *s = (CORBA::Long *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap4 (p, s);
    buf->rseek_rel (4*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_longlongs (CORBA::LongLong *p, CORBA::ULong l)
{
    if (!buf->ralign (8))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 8*l);

    if (buf->length() < 8*l)
        return 0;

    CORBA::LongLong *s = (CORBA::LongLong *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap8 (p, s);
    buf->rseek_rel (8*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ulongs (CORBA::ULong *p, CORBA::ULong l)
{
    if (!buf->ralign (4))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 4*l);

    if (buf->length() < 4*l)
        return 0;

    CORBA::ULong *s = (CORBA::ULong *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap4 (p, s);
    buf->rseek_rel (4*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_ulonglongs (CORBA::ULongLong *p, CORBA::ULong l)
{
    if (!buf->ralign (8))
        return 0;

    if (data_bo == mach_bo)
        return buf->get (p, 8*l);

    if (buf->length() < 8*l)
        return 0;

    CORBA::ULongLong *s = (CORBA::ULongLong *)buf->data();
    for (CORBA::Long i = l; --i >= 0; ++p, ++s)
        swap8 (p, s);
    buf->rseek_rel (8*l);

    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_floats (CORBA::Float *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p) {
        if (!get_float (*p))
            return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_doubles (CORBA::Double *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p) {
        if (!get_double (*p))
            return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_longdoubles (CORBA::LongDouble *p, CORBA::ULong l)
{
    for (CORBA::Long i = l; --i >= 0; ++p) {
        if (!get_longdouble (*p))
            return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_chars (CORBA::Char *p, CORBA::ULong l)
{
  if (!conv) {
    return buf->get (p, l);
  }
  return conv->get_chars (*this, p, l);
}

CORBA::Boolean
MICO::CDRDecoder::get_chars_raw (CORBA::Char *p, CORBA::ULong l)
{
    return buf->get (p, l);
}

CORBA::Boolean
MICO::CDRDecoder::get_wchars (CORBA::WChar *p, CORBA::ULong l)
{
  if (!conv) {
    return buf->get (p, l * sizeof (CORBA::WChar));
  }
  return conv->get_wchars (*this, p, l);
}

CORBA::Boolean
MICO::CDRDecoder::get_booleans (CORBA::Boolean *p, CORBA::ULong l)
{
    return buf->get (p, l);
}

CORBA::Boolean
MICO::CDRDecoder::get_string (CORBA::String_out s)
{
  if (!conv) {
    CORBA::ULong len;
    if (!get_ulong (len))
        return 0;
    char * p = CORBA::string_alloc (len-1);
    if (!buf->get (p, len)) {
      CORBA::string_free (p);
      return 0;
    }
    s = p;
    return 1;
  }

  return conv->get_string (*this, s, 0);
}

CORBA::Boolean
MICO::CDRDecoder::get_string_raw (CORBA::String_out s)
{
    CORBA::ULong len;
    if (!get_ulong (len))
        return 0;
    ((void) ((len >= 1) ? 0 : (__assert_fail ("len >= 1", "codec.cc", 1949, __PRETTY_FUNCTION__), 0)));

    s = CORBA::string_alloc (len-1);
    if (!buf->get (s.ptr(), len)) {
        CORBA::string_free (s);
        return 0;
    }
    ((void) ((s[len-1] == 0) ? 0 : (__assert_fail ("s[len-1] == 0", "codec.cc", 1956, __PRETTY_FUNCTION__), 0)));
    return 1;
}

CORBA::Boolean
MICO::CDRDecoder::get_wstring (CORBA::WString_out s)
{
  if (!conv) {
    CORBA::ULong len;
    if (!get_ulong (len))
        return 0;
    CORBA::WChar * p = CORBA::wstring_alloc (len-1);
    if (!buf->get (p, len * sizeof (CORBA::WChar))) {
      CORBA::wstring_free (p);
      return 0;
    }
    s = p;
    return 1;
  }

  return conv->get_wstring (*this, s, 0);
}

CORBA::Boolean
MICO::CDRDecoder::get_fixed (FixedBase::FixedValue &value,
                             CORBA::UShort digits,
                             CORBA::Short scale)
{
    value.length (digits+1);

    int s = 0, n = value.length();
    CORBA::Octet o;

    if (n == 1) {
        if (!get_octet (o))
            return 0;
        value[0] = ((o & 0xf) == 0xd);
        return 1;
    }
    if ((n & 1)) {
        if (!get_octet (o))
            return 0;
        value[0] = (o & 0xf);
        s = 1;
    }
    for (int i = s; i < n-2; i+=2) {
        if (!get_octet (o))
            return 0;
        value[i] = ((o >> 4) & 0xf);
        value[i+1] = (o & 0xf);
    }
    if (!get_octet (o))
        return 0;
    value[n-2] = ((o >> 4) & 0xf);
    value[n-1] = ((o & 0xf) == 0xd);
    return 1;
}

CORBA::DataDecoder *
MICO::CDRDecoder::clone () const
{
    return new CDRDecoder (new CORBA::Buffer (*buf), 1, data_bo,
                           (conv ? conv->clone() : 0), 1,
                           (vstate ? new ValueState (*vstate) : 0), 1);
}

CORBA::DataDecoder *
MICO::CDRDecoder::clone (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                         CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c,
                         ValueState *vs,
                         CORBA::Boolean dofree_vs) const
{
    return new CDRDecoder (b, dofree_b, data_bo, c, dofree_c,
                           vs, dofree_vs);
}

CORBA::DataEncoder *
MICO::CDRDecoder::encoder () const
{
    return new CDREncoder (new CORBA::Buffer (*buf), 1, data_bo,
                           (conv ? conv->clone() : 0), 1,
                           0, 1);
}

CORBA::DataEncoder *
MICO::CDRDecoder::encoder (CORBA::Buffer *b, CORBA::Boolean dofree_b,
                           CORBA::CodeSetCoder *c, CORBA::Boolean dofree_c
                           ) const
{
    return new CDREncoder (b, dofree_b, data_bo, c, dofree_c,
                           0, 1);
}

const char *
MICO::CDRDecoder::type () const
{
    return "cdr";
}

CORBA::ByteOrder
MICO::CDRDecoder::byteorder () const
{
    return data_bo;
}

void
MICO::CDRDecoder::byteorder (CORBA::ByteOrder _bo)
{
    data_bo = _bo;
}

CORBA::ULong
MICO::CDRDecoder::max_alignment () const
{
    return 8;
}
# 8 "orb_all.cc" 2
# 1 "context.cc" 1
# 24 "context.cc"
# 1 "/usr/include/string.h" 1 3 4
# 25 "context.cc" 2

# 1 "../include/CORBA-SMALL.h" 1
# 27 "context.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 28 "context.cc" 2
# 1 "../include/mico/throw.h" 1
# 29 "context.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 30 "context.cc" 2


CORBA::Context::Context (const char *name, Context_ptr parent)
    : _myparent (parent), _properties (new NVList), _name (name)
{
}

CORBA::Context::Context (DataDecoder &dc)
{
    CORBA::Boolean r = decode (dc);
    ((void) ((r) ? 0 : (__assert_fail ("r", "context.cc", 40, __PRETTY_FUNCTION__), 0)));
}

CORBA::Context::~Context ()
{
}

CORBA::Boolean
CORBA::Context::match (const char *value, const char *pattern)
{
    ULong l = strlen (pattern);
    if (l > 0 && pattern[l-1] == '*')
        return !strncmp (value, pattern, l-1);

    return !strcmp (value, pattern);
}

void
CORBA::Context::encode (DataEncoder &ec, ContextList_ptr clist) const
{
    NVList_var out;
    if (!CORBA::is_nil (clist)) {
        ((Context_ptr)this)->get_values ("", 0, clist, out);
    } else {
        ((Context_ptr)this)->get_values ("", 0, "*", out);
    }

    ec.seq_begin (2*out->count());
    for (CORBA::ULong i = 0; i < out->count(); ++i) {
        NamedValue_ptr nv = out->item(i);
        ec.put_string (nv->name());
        nv->value()->marshal (ec);
    }
    ec.seq_end ();
}



CORBA::Boolean
CORBA::Context::decode (DataDecoder &dc)
{

    _properties = new NVList;

    ULong len;
    if (!(dc.seq_begin (len))) return 0;
    if (!((len & 1) == 0)) return 0;
    {
        String_var s;
        Any a;
        for (CORBA::ULong i = 0; i < len; i += 2) {
            if (!(dc.get_string (s.out()))) return 0;
            if (!(a.demarshal (_tc_string, dc))) return 0;
            set_one_value (s, a);
        }
    }
    if (!(dc.seq_end ())) return 0;
    return 1;
}



const char *
CORBA::Context::context_name () const
{
    return _name.c_str();
}

CORBA::Context_ptr
CORBA::Context::parent () const
{
    return _myparent;
}

void
CORBA::Context::create_child (const char *name, Context_out out)
{
    out = new Context (name, this);
    _childs.push_back (_duplicate (out));
}

void
CORBA::Context::set_one_value (const char *name, const Any &val)
{
    (this)->_check ();

    if (!name || !&val)
        mico_throw (CORBA::BAD_PARAM());

    TypeCode_var tc = ((Any &)val).type();
    if (tc->unalias()->kind() != tk_string)
        mico_throw (CORBA::BAD_PARAM());

    for (CORBA::ULong i = 0; i < _properties->count(); ++i) {
        NamedValue_ptr nv = _properties->item(i);
        if (!strcmp (nv->name(), name)) {
            *nv->value() = val;
            return;
        }
    }
    _properties->add_value (name, val, 0);
}

void
CORBA::Context::set_values (NVList_ptr nvlist)
{
    for (CORBA::ULong i = 0; i < nvlist->count(); ++i) {
        NamedValue_ptr nv = nvlist->item (i);
        set_one_value (nv->name(), *nv->value());
    }
}

void
CORBA::Context::delete_values (const char *pattern)
{
    if (!pattern || !strlen (pattern))
        mico_throw (CORBA::BAD_PARAM());

    CORBA::Boolean found = 0;
    for (CORBA::ULong i = 0; i < _properties->count(); ) {
        if (match (_properties->item(i)->name(), pattern)) {
            found = 1;
            _properties->remove(i);
        } else {
            ++i;
        }
    }
    if (!found)
        mico_throw (CORBA::BAD_CONTEXT());
}

void
CORBA::Context::get_values (const char *scope,
                            Flags flags, const char *pattern,
                            NVList_out out)
{
    if (!pattern || !strlen (pattern))
        mico_throw (CORBA::BAD_PARAM());

    ContextList_var patterns = new ContextList;
    patterns->add (pattern);
    get_values (scope, flags, patterns, out);
}

void
CORBA::Context::get_values (const char *scope,
                            Flags flags,
                            ContextList_ptr patterns,
                            NVList_out out)
{
    (this)->_check ();

    if (scope && strlen (scope) && strcmp (scope, _name.c_str())) {
        if (CORBA::is_nil (_myparent))
            mico_throw (CORBA::BAD_CONTEXT());
        _myparent->get_values (scope, flags, patterns, out);
        return;
    }
    if (!(flags & CTX_RESTRICT_SCOPE) && !CORBA::is_nil (_myparent)) {
        _myparent->get_values ("", flags, patterns, out);
    } else {
        out = new NVList;
    }
    for (CORBA::ULong i = 0; i < _properties->count(); ++i) {
        NamedValue_ptr nv = _properties->item(i);
        for (CORBA::ULong k = 0; k < patterns->count(); ++k) {
            if (match (nv->name(), patterns->item(k))) {
                CORBA::ULong j;
                for (j = 0; j < out->count(); ++j) {
                    if (!strcmp (out->item(j)->name(), nv->name())) {
                        *out->item(j)->value() = *nv->value();
                        break;
                    }
                }
                if (j == out->count()) {
                    out->add_value (nv->name(), *nv->value(), nv->flags());
                }
            }
        }
    }
}
# 9 "orb_all.cc" 2
# 1 "dii.cc" 1
# 25 "dii.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "dii.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "dii.cc" 2

# 1 "/usr/include/ctype.h" 1 3 4
# 30 "dii.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "dii.cc" 2
# 1 "../include/mico/throw.h" 1
# 32 "dii.cc" 2
# 1 "../include/mico/impl.h" 1
# 33 "dii.cc" 2
# 1 "../include/mico/intercept.h" 1
# 34 "dii.cc" 2
# 1 "../include/mico/util.h" 1
# 35 "dii.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 36 "dii.cc" 2
# 1 "../include/mico/os-misc.h" 1
# 37 "dii.cc" 2
# 1 "../include/mico/basic_seq.h" 1
# 38 "dii.cc" 2
# 55 "dii.cc"
CORBA::NamedValue::NamedValue (const char *nameval, const Any &val, Flags flagsval)
    : _n (nameval), _v (val), _f (flagsval)
{
}

CORBA::NamedValue::NamedValue (const char *nameval, Flags flagsval)
    : _n (nameval), _f (flagsval)
{
}

CORBA::NamedValue::NamedValue ()
    : _n ((const char *)0), _f (0)
{

}

CORBA::NamedValue &
CORBA::NamedValue::operator= (const NamedValue &nv)
{
    _n = nv._n;
    _f = nv._f;
    _v = nv._v;
    return *this;
}

CORBA::NamedValue::~NamedValue ()
{
}





CORBA::NVList::NVList (ULong countval)
{
    _vec.reserve (countval);
}

CORBA::NVList::~NVList ()
{
}

CORBA::NamedValue_ptr
CORBA::NVList::add (Flags flags)
{
    (this)->_check ();

    _vec.push_back (new NamedValue ("", flags));
    return _vec.back();
}

CORBA::NamedValue_ptr
CORBA::NVList::add_item (const char *name, Flags flags)
{
    (this)->_check ();

    _vec.push_back (new NamedValue (name, flags));
    return _vec.back();
}

CORBA::NamedValue_ptr
CORBA::NVList::add_value (const char *name, const Any &val, Flags flags)
{
    _vec.push_back (new NamedValue (name, val, flags));
    return _vec.back();
}

CORBA::NamedValue_ptr
CORBA::NVList::add_item_consume (char *name, Flags flags)
{
    (this)->_check ();

    _vec.push_back (new NamedValue (name, flags));
    CORBA::string_free (name);
    return _vec.back();
}

CORBA::NamedValue_ptr
CORBA::NVList::add_value_consume (char *name, Any *val, Flags flags)
{
    _vec.push_back (new NamedValue (name, *val, flags));
    delete val;
    CORBA::string_free (name);
    return _vec.back();
}

CORBA::NamedValue_ptr
CORBA::NVList::item (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    return _vec[idx];
}

void
CORBA::NVList::remove (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    _vec.erase (_vec.begin() + idx);
}

CORBA::Boolean
CORBA::NVList::copy (NVList_ptr src, Flags f)
{
    NVList_ptr dst = this;

    int dst_count = dst->count ();
    int src_count = src->count ();

    NamedValue_ptr dst_nv, src_nv;

    for (int d = 0, s = 0;; ++d, ++s) {
        dst_nv = NamedValue::_nil();
        for ( ; d < dst_count; ++d) {
            dst_nv = dst->item (d);
            if (dst_nv->flags () & f)
                break;
        }
        src_nv = NamedValue::_nil();
        for ( ; s < src_count; ++s) {
            src_nv = src->item (s);
            if (src_nv->flags () & f)
                break;
        }
        if (s >= src_count || d >= dst_count) {

            if (!(s >= src_count && d >= dst_count))
                return 0;
            break;
        }

        if (!((src_nv->flags() & f) == (dst_nv->flags() & f)))
            return 0;


        *dst_nv->value() = *src_nv->value();
    }
    return 1;
}





CORBA::Environment::Environment (Principal_ptr pr)
{
    _exceptn = __null;
    _princ = CORBA::Principal::_duplicate (pr);
}

CORBA::Environment::~Environment ()
{
    if (_exceptn)
        delete _exceptn;
    CORBA::release (_princ);
}

void
CORBA::Environment::exception (Exception *e)
{
    if (_exceptn)
        delete _exceptn;
    _exceptn = e;
}

void
CORBA::Environment::clear ()
{
    (this)->_check ();

    if (_exceptn)
        delete _exceptn;
    _exceptn = __null;
}






namespace CORBA {
  vector<CORBA::Octet> Principal::_peer_info;
};




CORBA::Principal::Principal (CORBA::Transport *t)
{
    _rep = _peer_info;

    _transp = t;
}

CORBA::Principal::Principal (DataDecoder &dc, CORBA::Transport *t)
{

    _transp = t;
    CORBA::Boolean r = decode (dc);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dii.cc", 259, __PRETTY_FUNCTION__), 0)));
}

CORBA::Principal::~Principal ()
{
}

CORBA::Boolean
CORBA::Principal::operator== (const Principal &p) const
{
    return _rep == p._rep;
}

void
CORBA::Principal::encode (DataEncoder &ec) const
{
    ec.seq_begin (_rep.size());
    {
        if (_rep.size() > 0) {
            ((void) ((_rep.size() < 2 || &_rep[0] + 1 == &_rep[1]) ? 0 : (__assert_fail ("_rep.size() < 2 || &_rep[0] + 1 == &_rep[1]", "dii.cc", 278, __PRETTY_FUNCTION__), 0)));
            ec.put_octets (&_rep[0], _rep.size());
        }
    }
    ec.seq_end ();
}



CORBA::Boolean
CORBA::Principal::decode (DataDecoder &dc)
{
    ULong len;
    if (!(dc.seq_begin (len))) return 0;
    {
        _rep.erase (_rep.begin(), _rep.end());
        if (len > 0) {
            if (dc.buffer()->length() < len)
                return 0;
            _rep.insert (_rep.begin(),
                         dc.buffer()->data(),
                         dc.buffer()->data() + len);
            dc.buffer()->rseek_rel (len);
        }
    }
    if (!(dc.seq_end ())) return 0;
    return 1;
}



CORBA::Principal::PropertyNameList_ptr
CORBA::Principal::list_properties ()
{
    PropertyNameList_ptr pl = new PropertyNameList;
    pl->length (3);

    (*pl)[0] = (const char *)"peer-info";
    (*pl)[1] = (const char *)"auth-method";
    (*pl)[2] = (const char *)"peer-address";
    return pl;
}

CORBA::Any*
CORBA::Principal::get_property (const char *prop_name)
{
    if (!strcmp ("peer-info", prop_name)) {
        Any *a = new Any;
        if (_rep.size() > 0) {
            OctetSeq os (_rep.size(), _rep.size(), &_rep[0], 0);
            *a <<= os;
        } else {
            *a <<= OctetSeq();
        }
        return a;
    }
    if (!strcmp ("auth-method", prop_name)) {
        Any *a = new Any;
        *a <<= "basic";
        return a;
    }
    if (!strcmp ("peer-address", prop_name)) {
        Any *a = new Any;
        if (_transp) {
            *a <<= _transp->peer()->stringify().c_str();
        } else {
            *a <<= "";
        }
        return a;
    }
    return new Any;
}

void
CORBA::Principal::set_peer_info (const OctetSeq &i)
{
    _peer_info.erase (_peer_info.begin(), _peer_info.end());
    _peer_info.insert (_peer_info.begin(),
                       &i[0], &i[0] + i.length());
}





CORBA::ContextList::ContextList ()
{
}

CORBA::ContextList::~ContextList ()
{
}

void
CORBA::ContextList::add (const char *ctxt)
{
    (this)->_check ();

    if (!ctxt)
        mico_throw (CORBA::BAD_PARAM());

    _vec.push_back (ctxt);
}

void
CORBA::ContextList::add_consume (char *ctxt)
{
    (this)->_check ();

    if (!ctxt)
        mico_throw (CORBA::BAD_PARAM());

    _vec.push_back (ctxt);
    CORBA::string_free (ctxt);
}

const char *
CORBA::ContextList::item (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    return _vec[idx].c_str();
}

void
CORBA::ContextList::remove (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    _vec.erase (_vec.begin() + idx);
}





CORBA::ExceptionList::ExceptionList ()
{
}

CORBA::ExceptionList::~ExceptionList ()
{
}

void
CORBA::ExceptionList::add (TypeCode_ptr tc)
{
    (this)->_check ();

    _vec.push_back (TypeCode::_duplicate (tc));
}

void
CORBA::ExceptionList::add_consume (TypeCode_ptr tc)
{
    (this)->_check ();

    _vec.push_back (tc);
}

CORBA::TypeCode_ptr
CORBA::ExceptionList::item (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    return TypeCode::_duplicate (_vec[idx]);
}

void
CORBA::ExceptionList::remove (ULong idx)
{
    (this)->_check ();

    if (idx >= _vec.size())
        mico_throw (CORBA::Bounds());
    _vec.erase (_vec.begin() + idx);
}





CORBA::RequestCallback::~RequestCallback ()
{
}





CORBA::Request::Request ()
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "dii.cc", 476, __PRETTY_FUNCTION__), 0)));
}

CORBA::Request::Request (Object_ptr o, Context_ptr c,
                         const char *op,
                         NVList_ptr argumentsval,
                         NamedValue_ptr resultval,
                         Flags f)
{
    if (CORBA::is_nil (o) || !op)
        mico_throw (CORBA::BAD_PARAM());

    (o)->_check (CORBA::OBJECT_NOT_EXIST());

    if (!o->_ior())

        mico_throw (NO_IMPLEMENT());

    _object = Object::_duplicate (o);
    _context = Context::_duplicate (c);
    _opname = op;
    _args = NVList::_duplicate (argumentsval);
    _res = NamedValue::_duplicate (resultval);
    _flags = f;

    _invoke_pending = 0;

    ORB_ptr orb = o->_orbnc();

    if (CORBA::is_nil (_args))
        orb->create_list (0, _args);
    if (CORBA::is_nil (_res))
        orb->create_named_value (_res);
    orb->create_environment (_environm);

    orb->create_context_list (_clist);
    orb->create_exception_list (_elist);
    _orbreq = new MICO::LocalRequest (this);
    _iceptreq = Interceptor::ClientInterceptor::_create_request (
        _object, _opname, *_orbreq->context(), this);
    _cb = 0;
}

CORBA::Request::Request (Object_ptr o,
                         Context_ptr c,
                         const char *op,
                         NVList_ptr argumentsval,
                         NamedValue_ptr resultval,
                         ExceptionList_ptr el,
                         ContextList_ptr cl,
                         Flags f)
{
    if (CORBA::is_nil (o) || !op)
        mico_throw (CORBA::BAD_PARAM());

    (o)->_check (CORBA::OBJECT_NOT_EXIST());

    if (!o->_ior())

        mico_throw (NO_IMPLEMENT());

    _object = Object::_duplicate (o);
    _context = Context::_duplicate (c);
    _opname = op;
    _args = NVList::_duplicate (argumentsval);
    _res = NamedValue::_duplicate (resultval);
    _flags = f;
    _elist = ExceptionList::_duplicate (el);
    _clist = ContextList::_duplicate (cl);

    _invoke_pending = 0;

    ORB_ptr orb = o->_orbnc();

    if (CORBA::is_nil (_args))
        orb->create_list (0, _args);
    if (CORBA::is_nil (_res))
        orb->create_named_value (_res);
    orb->create_environment (_environm);

    if (CORBA::is_nil (_clist))
        orb->create_context_list (_clist);
    if (CORBA::is_nil (_elist))
        orb->create_exception_list (_elist);
    _orbreq = new MICO::LocalRequest (this);
    _iceptreq = Interceptor::ClientInterceptor::_create_request (
        _object, _opname, *_orbreq->context(), this);
    _cb = 0;
}

CORBA::Request::Request (Object_ptr o, const char *op)
{
    if (CORBA::is_nil (o) || !op)
        mico_throw (CORBA::BAD_PARAM());

    (o)->_check (CORBA::OBJECT_NOT_EXIST());

    if (!o->_ior())

        mico_throw (NO_IMPLEMENT());

    _object = Object::_duplicate (o);
    _opname = op;

    _invoke_pending = 0;

    ORB_ptr orb = o->_orbnc();

    _context = Context::_nil();
    orb->create_environment (_environm);
    orb->create_list (0, _args);
    orb->create_named_value (_res);

    orb->create_context_list (_clist);
    orb->create_exception_list (_elist);
    _flags = 0;
    _orbreq = new MICO::LocalRequest (this);
    _iceptreq = Interceptor::ClientInterceptor::_create_request (
        _object, _opname, *_orbreq->context(), this);
    _cb = 0;
}

CORBA::Request::~Request ()
{
    if (_invoke_pending)
        _object->_orbnc()->cancel (_msgid);
    CORBA::release (_context);
    CORBA::release (_environm);
    CORBA::release (_args);
    CORBA::release (_res);
    CORBA::release (_clist);
    CORBA::release (_elist);
    CORBA::release (_orbreq);
    CORBA::release (_iceptreq);
}

void
CORBA::Request::decode_user_exception ()
{
    Exception *ex = _environm->exception();
    if (ex && _elist->count() > 0) {
        UnknownUserException *uuex =
          UnknownUserException::_downcast (ex);
        if (uuex) {

            const char *repoid = uuex->_except_repoid ();
            TypeCode_ptr tc;
            for (CORBA::ULong i = 0; i < _elist->count(); ++i) {
                tc = _elist->item (i);
                if (!strcmp (repoid, tc->id())) {
                    uuex->exception (tc);
                    break;
                }
            }
        }
    }
}

void
CORBA::Request::callback (ORB_ptr, ULong, ORBCallback::Event ev)
{
    ((void) ((ev == ORBCallback::Invoke) ? 0 : (__assert_fail ("ev == ORBCallback::Invoke", "dii.cc", 637, __PRETTY_FUNCTION__), 0)));
    if (_cb) {
        _cb->callback (this, RequestCallback::RequestDone);
        _cb = 0;
    }
}

void
CORBA::Request::ctx (Context_ptr c)
{
    (this)->_check ();

    CORBA::release (_context);
    _context = Context::_duplicate (c);
}

CORBA::Any &
CORBA::Request::add_in_arg ()
{
    return *arguments()->add(ARG_IN)->value();
}

CORBA::Any &
CORBA::Request::add_in_arg (const char *name)
{
    return *arguments()->add_item(name, ARG_IN)->value();
}

CORBA::Any &
CORBA::Request::add_inout_arg ()
{
    return *arguments()->add(ARG_INOUT)->value();
}

CORBA::Any &
CORBA::Request::add_inout_arg (const char *name)
{
    return *arguments()->add_item(name, ARG_INOUT)->value();
}

CORBA::Any &
CORBA::Request::add_out_arg ()
{
    return *arguments()->add(ARG_OUT)->value();
}

CORBA::Any &
CORBA::Request::add_out_arg (const char *name)
{
    return *arguments()->add_item(name, ARG_OUT)->value();
}

void
CORBA::Request::set_return_type (TypeCode_ptr tc)
{
    result()->value()->set_type (tc);
}

CORBA::Any &
CORBA::Request::return_value ()
{
    return *result()->value();
}

void
CORBA::Request::invoke ()
{
    send_deferred ();
    get_response ();
}

void
CORBA::Request::send_oneway ()
{
    (this)->_check ();

    if (!Interceptor::ClientInterceptor::
        _exec_initialize_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  _environm)) {
        return;
    }

    ORB_ptr orb = _object->_orbnc();
    orb->invoke_async (_object, _orbreq, Principal::_nil(), 0);

    Interceptor::ClientInterceptor::
        _exec_after_marshal ((Interceptor::LWRequest_ptr)_iceptreq, _environm);
}

void
CORBA::Request::send_deferred (RequestCallback *cb)
{
    (this)->_check ();

    _cb = cb;

    if (!Interceptor::ClientInterceptor::
        _exec_initialize_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  _environm)) {
        if (_cb)
            _cb->callback (this, RequestCallback::RequestDone);
        _cb = 0;
        return;
    }

    _invoke_pending = 1;

    ORB_ptr orb = _object->_orbnc();
    _msgid = orb->new_msgid();
    orb->invoke_async (_object, _orbreq, Principal::_nil(),
                       1, _cb ? this : 0, _msgid);

    if (_invoke_pending && !Interceptor::ClientInterceptor::
        _exec_after_marshal ((Interceptor::LWRequest_ptr)_iceptreq, _environm)) {
        orb->cancel (_msgid);
        _invoke_pending = 0;
        if (_cb)
            _cb->callback (this, RequestCallback::RequestDone);
        _cb = 0;
        return;
    }
}

void
CORBA::Request::get_response (Boolean block)
{
    (this)->_check ();

    if (!_invoke_pending)
        return;

    ORB_ptr orb = _object->_orbnc();
    InvokeStatus rs = InvokeOk;

    while (_invoke_pending) {
        Object_var nobj;
        ORBRequest *dummy;

        if (block) {
            CORBA::Boolean r = orb->wait (_msgid);
            ((void) ((r) ? 0 : (__assert_fail ("r", "dii.cc", 777, __PRETTY_FUNCTION__), 0)));
        } else {
            if (!orb->wait (_msgid, 0))
                return;
        }


        if (!Interceptor::ClientInterceptor::
            _exec_before_unmarshal ((Interceptor::LWRequest_ptr)_iceptreq,
                                    _environm)) {
            orb->cancel (_msgid);
            _invoke_pending = 0;
            _cb = 0;
            return;
        }

        CORBA::GIOP::AddressingDisposition ad;
        rs = orb->get_invoke_reply (_msgid, nobj, dummy, ad);

        switch (rs) {
        case InvokeForward:

            ((void) ((_object.in() && nobj.in()) ? 0 : (__assert_fail ("_object.in() && nobj.in()", "dii.cc", 799, __PRETTY_FUNCTION__), 0)));
            _object->_forward (nobj);
            _msgid = orb->invoke_async (_object, _orbreq, Principal::_nil());
            break;

        case InvokeOk:
            _invoke_pending = 0;
            break;

        case CORBA::InvokeSysEx:
            if (_object->_is_forwarded()) {
# 822 "dii.cc"
                CORBA::SystemException *sysex =
                    CORBA::SystemException::_downcast (env()->exception());
                ((void) ((sysex) ? 0 : (__assert_fail ("sysex", "dii.cc", 824, __PRETTY_FUNCTION__), 0)));
                if (sysex->completed() == CORBA::COMPLETED_NO &&
                    (CORBA::COMM_FAILURE::_downcast (sysex) ||
                     CORBA::TRANSIENT::_downcast (sysex) ||
                     CORBA::OBJECT_NOT_EXIST::_downcast (sysex))) {
                    _object->_unforward();
                    env()->clear();
                    _msgid = orb->invoke_async (_object, _orbreq,
                                                Principal::_nil());
                    break;
                }
            }
            _invoke_pending = 0;
            break;

        case InvokeUsrEx:
            decode_user_exception ();
            _invoke_pending = 0;
            break;

        case InvokeAddrDisp:
            _object->_ior_fwd()->addressing_disposition (ad);
            _msgid = orb->invoke_async (_object, _orbreq, Principal::_nil());
            break;

        default:
            ((void) ((0) ? 0 : (__assert_fail ("0", "dii.cc", 850, __PRETTY_FUNCTION__), 0)));
        }
    }

    if (!Interceptor::ClientInterceptor::
        _exec_finish_request ((Interceptor::LWRequest_ptr)_iceptreq, _environm)) {
        _cb = 0;
        return;
    }

    _cb = 0;

    if (!_invoke_pending && rs == CORBA::InvokeSysEx)
        env()->exception()->_raise();
}

CORBA::Boolean
CORBA::Request::poll_response ()
{

    get_response (0);
    return !_invoke_pending;
}





MICO::LocalRequest::LocalRequest ()
    : _req (CORBA::Request::_nil()), _have_except (0), _have_result (0)
{
}

MICO::LocalRequest::LocalRequest (CORBA::Request_ptr r)
    : _req (r), _have_except (0), _have_result (0)
{
}

MICO::LocalRequest::~LocalRequest ()
{
}

const char *
MICO::LocalRequest::op_name()
{
    return _req->operation();
}

CORBA::Boolean
MICO::LocalRequest::get_in_args (CORBA::NVList_ptr iparams,
                                 CORBA::Context_ptr &ctx)
{
    if (!iparams->copy (_req->arguments(), CORBA::ARG_IN|CORBA::ARG_INOUT))
        return 0;
    ctx = CORBA::Context::_duplicate (_req->ctx());
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::get_in_args (StaticAnyList *iparams,
                                 CORBA::Context_ptr &ctx)
{
    CORBA::NVList_ptr args = _req->arguments();

    if (args->count() != iparams->size())
        return 0;

    CORBA::NamedValue_ptr nv;
    for (mico_vec_size_type i0 = 0; i0 < iparams->size(); ++i0) {
        nv = args->item(i0);
        if ((*iparams)[i0]->flags() != nv->flags())
            return 0;
        if ((*iparams)[i0]->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            if (!nv->value()->to_static_any (*(*iparams)[i0]))
                return 0;
        }
    }
    ctx = CORBA::Context::_duplicate (_req->ctx());
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::get_in_args (CORBA::DataEncoder *ec)
{

    CORBA::DataEncoder::ValueState vstate;
    ec->valuestate (&vstate, 0);

    CORBA::NVList_ptr nv = _req->arguments();
    for (CORBA::ULong i = 0; i < nv->count(); ++i) {
        if (nv->item(i)->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            if (!nv->item(i)->value()->marshal (*ec))
                return 0;
        }
    }
    if (!CORBA::is_nil (_req->ctx())) {
        ec->put_context (*_req->ctx(), _req->contexts());
    }
    ec->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::get_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams,
                                  CORBA::Exception *&except)
{
    if (_have_except) {
        CORBA::Exception *e = _req->env()->exception();
        ((void) ((e) ? 0 : (__assert_fail ("e", "dii.cc", 958, __PRETTY_FUNCTION__), 0)));
        except = e->_clone ();
    } else {
        except = 0;
        if (_have_result && res)
            *res = *_req->result()->value();
        if (!oparams->copy (_req->arguments(), CORBA::ARG_OUT|CORBA::ARG_INOUT))
            return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::get_out_args (CORBA::StaticAny *res,
                                  StaticAnyList *oparams,
                                  CORBA::Exception *&except)
{
    if (_have_except) {
        CORBA::Exception *e = _req->env()->exception();
        ((void) ((e) ? 0 : (__assert_fail ("e", "dii.cc", 977, __PRETTY_FUNCTION__), 0)));
        except = e->_clone ();
        return 1;
    }

    except = 0;

    CORBA::NVList_ptr args = _req->arguments();

    if (args->count() != oparams->size())
        return 0;

    if (_have_result && res) {
        if (!_req->result()->value()->to_static_any (*res))
            return 0;
    }

    CORBA::NamedValue_ptr nv;
    for (CORBA::ULong i0 = 0; i0 < args->count(); ++i0) {
        nv = args->item(i0);
        if ((*oparams)[i0]->flags() != nv->flags())
            return 0;
        if ((*oparams)[i0]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            if (!nv->value()->to_static_any (*(*oparams)[i0]))
                return 0;
        }
    }
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::get_out_args (CORBA::DataEncoder *ec,
                                  CORBA::Boolean &is_except)
{

    CORBA::DataEncoder::ValueState vstate;
    ec->valuestate (&vstate, 0);

    if (_have_except) {
        is_except = 1;
        CORBA::Exception *e = _req->env()->exception();
        ((void) ((e) ? 0 : (__assert_fail ("e", "dii.cc", 1018, __PRETTY_FUNCTION__), 0)));
        e->_encode (*ec);
    } else {
        is_except = 0;
        if (_have_result) {
            if (!_req->result()->value()->marshal (*ec))
                return 0;
        }
        CORBA::NVList_ptr nv = _req->arguments();
        for (CORBA::ULong i = 0; i < nv->count(); ++i) {
            if (nv->item(i)->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
                if (!nv->item(i)->value()->marshal (*ec))
                    return 0;
            }
        }
    }
    ec->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::set_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams)
{
    _have_except = 0;
    if (res) {
        _have_result = 1;
        *_req->result()->value() = *res;
    }
    return _req->arguments()->copy (oparams, CORBA::ARG_OUT|CORBA::ARG_INOUT);
}

CORBA::Boolean
MICO::LocalRequest::set_out_args (CORBA::StaticAny *res,
                                  StaticAnyList *oparams)
{
    CORBA::NVList_ptr args = _req->arguments();

    if (args->count() != oparams->size())
        return 0;

    _have_except = 0;
    _have_result = !!res;
    if (res)
        _req->result()->value()->from_static_any (*res);

    CORBA::NamedValue_ptr nv;
    for (mico_vec_size_type i0 = 0; i0 < oparams->size(); ++i0) {
        nv = args->item(i0);
        if ((*oparams)[i0]->flags() != nv->flags())
            return 0;
        if ((*oparams)[i0]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            nv->value()->from_static_any (*(*oparams)[i0]);
        }
    }
    return 1;
}

void
MICO::LocalRequest::set_out_args (CORBA::Exception *except)
{
    _have_except = 1;
    _have_result = 0;
    _req->env()->exception (except->_clone());
}

CORBA::Boolean
MICO::LocalRequest::set_out_args (CORBA::DataDecoder *dc, CORBA::Boolean is_ex)
{
    CORBA::Boolean ret;
    CORBA::TypeCode_var tc;


    CORBA::DataDecoder::ValueState vstate;
    dc->valuestate (&vstate, 0);

    if (is_ex) {
        _have_except = 1;
        _have_result = 0;
        CORBA::Exception *e = CORBA::Exception::_decode (*dc);
        ((void) ((e) ? 0 : (__assert_fail ("e", "dii.cc", 1097, __PRETTY_FUNCTION__), 0)));
        _req->env()->exception (e);
    } else {
        _have_except = 0;
        _have_result = 1;

        tc = _req->result()->value()->type();
        ret = _req->result()->value()->demarshal (tc, *dc);
        if (!ret) {
            dc->valuestate (0);
            return 0;
        }

        CORBA::NVList_ptr nv = _req->arguments();
        for (CORBA::ULong i = 0; i < nv->count(); ++i) {
            if (nv->item(i)->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
                tc = nv->item(i)->value()->type();
                ret = nv->item(i)->value()->demarshal (tc, *dc);
                if (!ret) {
                    dc->valuestate (0);
                    return 0;
                }
            }
        }
    }
    dc->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::copy_out_args (CORBA::ORBRequest *r)
{
    if (this == r)
        return 1;


    copy_svc (r);

    CORBA::Exception *ex = 0;
    if (!r->get_out_args (_req->result()->value(), _req->arguments(), ex))
        return 0;
    if (ex) {
        _have_except = 1;
        _have_result = 0;
        _req->env()->exception (ex);
    } else {
        _have_result = 1;
        _have_except = 0;
    }
    return 1;
}

CORBA::Boolean
MICO::LocalRequest::copy_in_args (CORBA::ORBRequest *req)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "dii.cc", 1152, __PRETTY_FUNCTION__), 0)));
    return 0;
}

const char *
MICO::LocalRequest::type ()
{
    return "local";
}

CORBA::Request_ptr
MICO::LocalRequest::request ()
{
    return _req;
}
# 10 "orb_all.cc" 2
# 1 "dsi.cc" 1
# 26 "dsi.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 27 "dsi.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 29 "dsi.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "dsi.cc" 2
# 1 "../include/mico/intercept.h" 1
# 32 "dsi.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "dsi.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "dsi.cc" 2


CORBA::ImplementationBase::ImplementationBase ()
{
    _morb = ORB_instance ("mico-local-orb");
    _mboa = _morb->BOA_instance ("mico-local-boa");
}

CORBA::ImplementationBase::~ImplementationBase ()
{
    _dispose_ref ();
    CORBA::release (_morb);
    CORBA::release (_mboa);
}

void
CORBA::ImplementationBase::_create_ref (
    const BOA::ReferenceData &id,
    InterfaceDef_ptr interf,
    ImplementationDef_ptr im,
    const char *repoid)
{
    Object_var p = _mboa->create (id, interf, im, this, repoid);
    ((void) ((!CORBA::is_nil (p)) ? 0 : (__assert_fail ("!CORBA::is_nil (p)", "dsi.cc", 57, __PRETTY_FUNCTION__), 0)));
    Object::operator= (*(Object_ptr)p);
}

void
CORBA::ImplementationBase::_restore_ref (
    Object_ptr orig_obj,
    const BOA::ReferenceData &id,
    InterfaceDef_ptr interf,
    ImplementationDef_ptr im)
{
    Object_var p = _mboa->restore (orig_obj, id, interf, im, this);
    ((void) ((!CORBA::is_nil (p)) ? 0 : (__assert_fail ("!CORBA::is_nil (p)", "dsi.cc", 69, __PRETTY_FUNCTION__), 0)));
    Object::operator= (*(Object_ptr)p);
}

void
CORBA::ImplementationBase::_dispose_ref ()
{
    _mboa->dispose (this);
}

const char *
CORBA::ImplementationBase::_impl_name (const char *)
{
    return _mboa->impl_name();
}

CORBA::ImplementationDef_ptr
CORBA::ImplementationBase::_find_impl (const char *repoid, const char *name)
{
    name = _impl_name (name);

    CORBA::Object_var obj;

    obj = _morb->resolve_initial_references ("ImplementationRepository");
    CORBA::ImplRepository_var imr = ImplRepository::_narrow (obj);

    if (CORBA::is_nil (imr)) {
      return CORBA::ImplementationDef::_nil ();
    }

    CORBA::ImplRepository::ImplDefSeq_var impls;
    CORBA::ImplementationDef_var impl;

    impls = imr->find_by_name (name);

    if (impls->length() > 0) {
      if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
        MICO::Logger::Stream (MICO::Logger::Info)
          << "Info: found impl repository entry: " << name << endl;
      }

      impl = CORBA::ImplementationDef::_duplicate (impls[(CORBA::ULong)0]);
      CORBA::ImplementationDef::ObjectInfoList_var objs = impl->objs();
      CORBA::ULong i;
      for (i = 0; i < objs->length(); ++i) {
        if (!strcmp (repoid, objs[i].repoid.in()))
          break;
      }
      if (i == objs->length()) {
        if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
          MICO::Logger::Stream (MICO::Logger::Info)
            << "Info: adding repo id: " << repoid
            << " to impl repository" << endl;
        }

        objs->length (objs->length()+1);
        objs[objs->length()-1].repoid = CORBA::string_dup (repoid);
        impl->objs (objs.in());
      }
    } else {
      if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
        MICO::Logger::Stream (MICO::Logger::Info)
          << "Info: creating impl repository entry: " << name << endl;
      }

      CORBA::ImplementationDef::ObjectInfoList objs;
      objs.length (1);
      objs[0].repoid = CORBA::string_dup (repoid);

      impl = imr->create (CORBA::ImplementationDef::ActivatePersistent,
                          objs, name, "");
    }
    return CORBA::ImplementationDef::_duplicate (impl);
}

CORBA::InterfaceDef_ptr
CORBA::ImplementationBase::_find_iface (const char *repoid)
{
    CORBA::Object_var obj =
        _orbnc()->resolve_initial_references ("InterfaceRepository");
    if (CORBA::is_nil (obj)) {
      return CORBA::InterfaceDef::_nil ();
    }

    CORBA::Repository_var ir = Repository::_narrow (obj);
    ((void) ((!CORBA::is_nil (ir)) ? 0 : (__assert_fail ("!CORBA::is_nil (ir)", "dsi.cc", 154, __PRETTY_FUNCTION__), 0)));

    CORBA::Contained_var contained = ir->lookup_id (repoid);
    if (CORBA::is_nil (contained))
        return CORBA::InterfaceDef::_nil();

    CORBA::InterfaceDef_var iface = CORBA::InterfaceDef::_narrow (contained);
    ((void) ((!CORBA::is_nil (iface)) ? 0 : (__assert_fail ("!CORBA::is_nil (iface)", "dsi.cc", 161, __PRETTY_FUNCTION__), 0)));
    return CORBA::InterfaceDef::_duplicate (iface);
}

CORBA::Boolean
CORBA::ImplementationBase::_save_object ()
{




    return 0;
}

CORBA::BOA_ptr
CORBA::ImplementationBase::_boa ()
{
    return CORBA::BOA::_duplicate (_mboa);
}

CORBA::ORB_ptr
CORBA::ImplementationBase::_orbnc ()
{

    return _morb;
}

CORBA::ORB_ptr
CORBA::ImplementationBase::_orb ()
{
    return CORBA::ORB::_duplicate (_morb);
}

CORBA::Object_ptr
CORBA::ImplementationBase::_this ()
{
    return CORBA::Object::_duplicate (this);
}





CORBA::ServerRequestBase::~ServerRequestBase ()
{
}





CORBA::DynamicImplementation::DynamicImplementation ()
{
}

CORBA::DynamicImplementation::~DynamicImplementation ()
{
}

CORBA::ServerRequestBase_ptr
CORBA::DynamicImplementation::make_request (CORBA::ORBRequest *req,
                                            CORBA::Object_ptr obj,
                                            CORBA::ULong msgid,
                                            CORBA::ObjectAdapter *oa,
                                            CORBA::Principal_ptr pr)
{
    return new ServerRequest (req, obj, msgid, oa, pr);
}

void
CORBA::DynamicImplementation::doinvoke (ServerRequestBase_ptr req,
                                        Environment &env)
{
    invoke ((ServerRequest_ptr)req, env);
}





CORBA::ServerRequest::ServerRequest (ORBRequest *r, Object_ptr o,
                                     MsgId id, CORBA::ObjectAdapter *oa,
                                     CORBA::Principal_ptr pr)
    : _oa (oa), _msgid (id),
      _obj(Object::_duplicate (o)),
      _req(ORBRequest::_duplicate (r)),
      _env (pr)
{
    _aborted = 0;
    _dir_params = NVList::_nil();
    _context = Context::_nil();
    _iceptreq = Interceptor::ServerInterceptor::_create_request (
        _obj, r->op_name(), *r->context(), this);
}

CORBA::ServerRequest::~ServerRequest ()
{
    if (!_canceled) {

        _req->context()->length (0);

        if (!_aborted && !Interceptor::ServerInterceptor::
            _exec_before_marshal ((Interceptor::LWServerRequest_ptr)_iceptreq,
                                  &_env)) {
            _aborted = 1;
        }


        set_out_args();


        CORBA::InvokeStatus stat = CORBA::InvokeOk;
        if (exception()) {
            if (CORBA::SystemException::_downcast (exception())) {
                stat = CORBA::InvokeSysEx;
            } else {
                stat = CORBA::InvokeUsrEx;
            }
        }
        _oa->answer_invoke (_msgid, _obj, _req, stat);

        if (!_aborted && !Interceptor::ServerInterceptor::
            _exec_finish_request ((Interceptor::LWServerRequest_ptr)_iceptreq,
                                  &_env)) {

        }
    }

    CORBA::release (_dir_params);
    CORBA::release (_context);
    CORBA::release (_iceptreq);
    CORBA::release (_obj);
    CORBA::release (_req);
}


const char *
CORBA::ServerRequest::operation ()
{
  return _req->op_name();
}

void
CORBA::ServerRequest::arguments (NVList_ptr & p)
{
  params (p);
}

void
CORBA::ServerRequest::set_result (const Any & val)
{
  _res = new CORBA::Any (val);
}

void
CORBA::ServerRequest::set_exception (const Any & val)
{
  _res = 0;
  _env.exception (Exception::_decode ((Any &) val));
  ((void) ((_env.exception()) ? 0 : (__assert_fail ("_env.exception()", "dsi.cc", 320, __PRETTY_FUNCTION__), 0)));
}


const char *
CORBA::ServerRequest::op_name ()
{
    return _req->op_name();
}

CORBA::OperationDef_ptr
CORBA::ServerRequest::op_def ()
{
    InterfaceDef_var iface = _obj->_get_interface ();
    ((void) ((!CORBA::is_nil (iface)) ? 0 : (__assert_fail ("!CORBA::is_nil (iface)", "dsi.cc", 334, __PRETTY_FUNCTION__), 0)));

    Contained_var cont = iface->lookup ((char *)op_name());
    ((void) ((!CORBA::is_nil (cont)) ? 0 : (__assert_fail ("!CORBA::is_nil (cont)", "dsi.cc", 337, __PRETTY_FUNCTION__), 0)));

    OperationDef_ptr opdef = OperationDef::_narrow (cont);
    ((void) ((!CORBA::is_nil (opdef)) ? 0 : (__assert_fail ("!CORBA::is_nil (opdef)", "dsi.cc", 340, __PRETTY_FUNCTION__), 0)));

    return opdef;
}

CORBA::Context_ptr
CORBA::ServerRequest::ctx ()
{
    ((void) ((!CORBA::is_nil (_dir_params)) ? 0 : (__assert_fail ("!CORBA::is_nil (_dir_params)", "dsi.cc", 348, __PRETTY_FUNCTION__), 0)));
    return _context;
}

CORBA::Boolean
CORBA::ServerRequest::params (NVList_ptr p)
{
    ((void) ((CORBA::is_nil (_dir_params)) ? 0 : (__assert_fail ("CORBA::is_nil (_dir_params)", "dsi.cc", 355, __PRETTY_FUNCTION__), 0)));
    _dir_params = p;

    if (!Interceptor::ServerInterceptor::
        _exec_initialize_request ((Interceptor::LWServerRequest_ptr)_iceptreq,
                                  &_env)) {
        _aborted = 1;
        return 0;
    }

    if (!_req->get_in_args (_dir_params, _context)) {
      if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
        MICO::Logger::Stream (MICO::Logger::Warning)
          << "Warning: cannot decode args in ServerRequest::params" << endl;
      }
      exception (new CORBA::MARSHAL());
      _aborted = 1;
      return 0;
    }

    if (!Interceptor::ServerInterceptor::
        _exec_after_unmarshal ((Interceptor::LWServerRequest_ptr)_iceptreq,
                               &_env)) {
        _aborted = 1;
        return 0;
    }
    return 1;
}

void
CORBA::ServerRequest::result (Any *val)
{
    _env.clear ();
    _res = val;
}

CORBA::Environment_ptr
CORBA::ServerRequest::environment ()
{
    return &_env;
}

void
CORBA::ServerRequest::exception (Any *val)
{
    _res = 0;
    _env.exception (Exception::_decode (*val));
    ((void) ((_env.exception()) ? 0 : (__assert_fail ("_env.exception()", "dsi.cc", 402, __PRETTY_FUNCTION__), 0)));
    delete val;
}

void
CORBA::ServerRequest::exception (Exception *except)
{
    _env.exception (except);
}

CORBA::Exception *
CORBA::ServerRequest::exception ()
{

    return _env.exception();
}

CORBA::Any *
CORBA::ServerRequest::result ()
{

    return _res;
}

CORBA::NVList_ptr
CORBA::ServerRequest::arguments ()
{

    return _dir_params;
}

void
CORBA::ServerRequest::set_out_args ()
{

    if (_env.exception()) {
        _req->set_out_args (_env.exception());
    } else if (!CORBA::is_nil (_dir_params)) {
        if (!_req->set_out_args (_res, _dir_params)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: cannot ServerRequest::set_out_args" << endl;
          }
          CORBA::MARSHAL ex (0, CORBA::COMPLETED_YES);
          _req->set_out_args (&ex);
        }
    }
}

CORBA::ORBRequest *
CORBA::ServerRequest::request ()
{
    return _req;
}
# 11 "orb_all.cc" 2
# 1 "iop.cc" 1
# 26 "iop.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 27 "iop.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 29 "iop.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "iop.cc" 2
# 1 "../include/mico/impl.h" 1
# 32 "iop.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "iop.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "iop.cc" 2





MICO::GIOPConnCallback::~GIOPConnCallback ()
{
}





MICO::GIOPInContext::GIOPInContext (GIOPCodec *codec, CORBA::Buffer *buf,
                                    CORBA::CodeSetCoder *csc)
{
    _buf = buf;
    _delete_buf = 1;

    _dc = codec->dc_proto();
    _dc->buffer (buf, 0);

    if (csc) {
      _dc->converter (csc, 0);
    }
}

MICO::GIOPInContext::~GIOPInContext ()
{
    if (_delete_buf)
        delete _buf;
}

void
MICO::GIOPInContext::buffer (CORBA::Buffer *b)
{
    if (_delete_buf)
        delete _buf;

    _dc->buffer (b, 0);
    _buf = b;
    _delete_buf = 0;
}

void
MICO::GIOPInContext::converters (CORBA::CodeSetCoder *csc)
{
    _dc->converter (csc, 0);
}

CORBA::DataDecoder *
MICO::GIOPInContext::_retn ()
{
    ((void) ((_delete_buf) ? 0 : (__assert_fail ("_delete_buf", "iop.cc", 87, __PRETTY_FUNCTION__), 0)));
    _delete_buf = 0;
    return _dc->clone (_buf, 1, _dc->converter(), 0);
}





MICO::GIOPOutContext::GIOPOutContext (GIOPCodec *codec,
                                      CORBA::CodeSetCoder *csc)
{
    _buf = new CORBA::Buffer;
    _delete_buf = 1;

    _ec = codec->ec_proto();
    _ec->buffer (_buf, 0);
    _ec->converter (csc, 0);
}

MICO::GIOPOutContext::GIOPOutContext (CORBA::DataEncoder *ec)
{
    _buf = ec->buffer();
    _delete_buf = 0;

    _ec = ec;
}

MICO::GIOPOutContext::~GIOPOutContext ()
{
    if (_delete_buf)
        delete _buf;
}

void
MICO::GIOPOutContext::converters (CORBA::CodeSetCoder *csc)
{
    _ec->converter (csc, 0);
}

void
MICO::GIOPOutContext::reset()
{
    _buf->reset();
}

CORBA::Buffer *
MICO::GIOPOutContext::_retn()
{
    ((void) ((_delete_buf) ? 0 : (__assert_fail ("_delete_buf", "iop.cc", 136, __PRETTY_FUNCTION__), 0)));
    _delete_buf = 0;
    return _buf;
}





MICO::GIOPCodec::GIOPCodec (CORBA::DataDecoder *_dc,
                            CORBA::DataEncoder *_ec,
                            CORBA::UShort giop_ver)
    : _dc_proto(_dc), _ec_proto(_ec)
{
    _giop_ver = giop_ver;

    if (_giop_ver > 0x0102) {
      _giop_ver = 0x0102;
    }

    GIOPOutContext ctx (this);
    _size_offset = put_header (ctx, CORBA::GIOP::Request);
    _headerlen = ctx.ec()->buffer()->length();
    _conv = 0;
    _codesets_sent = 0;
}

MICO::GIOPCodec::~GIOPCodec ()
{
    delete _ec_proto;
    delete _dc_proto;
    delete _conv;
}

CORBA::Boolean
MICO::GIOPCodec::setup_codeset_ids (CORBA::Object_ptr obj)
{
  CORBA::IORProfile *prof;
  CORBA::MultiComponent *comps;
  CORBA::Component *comp;
  MICO::CodesetComponent *csc = 0;

  ((void) ((!_conv) ? 0 : (__assert_fail ("!_conv", "iop.cc", 178, __PRETTY_FUNCTION__), 0)));





  if (_giop_ver == 0x0100) {
    _csid = 0;
    _wcsid = 0;
    _conv = new MICO::GIOP_1_0_CodeSetCoder ();
    return 1;
  }





  prof = obj->_ior_fwd()->active_profile();

  if (prof && (comps = prof->components())) {
    if ((comp = comps->component (CORBA::Component::TAG_CODE_SETS))) {
      csc = (MICO::CodesetComponent *) comp;
    }
  }





  prof = obj->_ior_fwd()->profile (CORBA::IORProfile::TAG_MULTIPLE_COMPONENTS,
                                   1);

  if (prof && (comps = prof->components())) {
    if ((comp = comps->component (CORBA::Component::TAG_CODE_SETS))) {
      csc = (MICO::CodesetComponent *) comp;
    }
  }

  if (csc) {
    _csid = csc->selected_cs();
    _wcsid = csc->selected_wcs();
  } else {

    _csid = CORBA::Codeset::special_cs(CORBA::Codeset::DefaultCS)->id();
    _wcsid = CORBA::Codeset::special_cs(CORBA::Codeset::DefaultWCS)->id();
  }

  if (_giop_ver == 0x0100) {
    _conv = new MICO::GIOP_1_0_CodeSetCoder ();
  }
  else if (_giop_ver == 0x0101) {
    _conv = new MICO::GIOP_1_1_CodeSetCoder (_csid);
  }
  else if (_giop_ver >= 0x0102) {
    _conv = new MICO::GIOP_1_2_CodeSetCoder (_csid, _wcsid);
  }

  _dc_proto->converter (_conv, 0);
  _ec_proto->converter (_conv, 0);

  if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
    if (csc) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: advertised code sets: " << endl;
      csc->print (MICO::Logger::Stream (MICO::Logger::GIOP));
    }
    else {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: no codesets tag found, using defaults." << endl;
    }

    if (_giop_ver == 0x0101) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP:    TCS-C is "
        << CORBA::Codeset::_find_info(_csid)->desc
        << endl;
    }
    else if (_giop_ver == 0x0102) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP:    TCS-C is "
        << CORBA::Codeset::_find_info(_csid)->desc
        << endl
        << "GIOP:    TCS-W is "
        << CORBA::Codeset::_find_info(_wcsid)->desc
        << endl;
    }
  }

  return _conv->isok();
}

CORBA::ULong
MICO::GIOPCodec::put_header (GIOPOutContext &out, CORBA::GIOP::MsgType mt)
{
    CORBA::ULong key;

    CORBA::DataEncoder *ec = out.ec();

    ec->struct_begin();
    {
        ec->arr_begin();
        {

            ec->put_chars_raw ((CORBA::Char *)"GIOP", 4);
        }
        ec->arr_end();

        ec->struct_begin();
        {
            ec->put_octet ((CORBA::Octet)(_giop_ver >> 8));
            ec->put_octet ((CORBA::Octet)_giop_ver);
        }
        ec->struct_end();

        if (_giop_ver == 0x0100) {
            ec->put_boolean (ec->byteorder() == CORBA::LittleEndian);
        } else {
            ec->put_octet ((ec->byteorder() == CORBA::LittleEndian)
                ? 1 : 0);
        }
        ec->put_octet (mt);
        key = ec->buffer()->wpos();
        ec->put_ulong (0);
    }
    ec->struct_end();

    return key;
}

void
MICO::GIOPCodec::put_contextlist (GIOPOutContext &out,
                                  const CORBA::IOP::ServiceContextList &ctx,
                                  CORBA::Boolean codesets)
{
    CORBA::DataEncoder *ec = out.ec();

    if (CORBA::Codeset::disabled())
        codesets = 0;

    ec->seq_begin (ctx.length() + !!codesets);
    {
        CORBA::DataEncoder::EncapsState state;
        for (CORBA::ULong i = 0; i < ctx.length(); ++i) {
            ec->struct_begin();
            {
                ec->put_ulong (ctx[i].context_id);


                ec->seq_begin (ctx[i].context_data.length());
                if (ctx[i].context_data.length() > 0) {
                    ec->put_octets (
                        (const CORBA::Octet *)&ctx[i].context_data[0],
                        ctx[i].context_data.length());
                }
                ec->seq_end();
            }
            ec->struct_end();
        }

        if (codesets) {
            ec->struct_begin();
            {
                ec->put_ulong (CORBA::IOP::CodeSets);
                ec->encaps_begin (state);
                ec->struct_begin ();
                {
                    ec->put_ulong (_csid);
                    ec->put_ulong (_wcsid);
                }
                ec->struct_end ();
                ec->encaps_end (state);
            }
            ec->struct_end();
        }
    }
    ec->seq_end ();
}

void
MICO::GIOPCodec::put_target (GIOPOutContext &out, CORBA::Object_ptr obj)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong active_index;
    CORBA::IORProfile *prof = obj->_ior_fwd()->active_profile (&active_index);
    ((void) ((prof) ? 0 : (__assert_fail ("prof", "iop.cc", 363, __PRETTY_FUNCTION__), 0)));

    CORBA::Long objkeylen;
    const CORBA::Octet *objkey = prof->objectkey (objkeylen);

    if (_giop_ver < 0x0102) {
        ec->seq_begin (objkeylen);
        ec->put_octets (objkey, objkeylen);
        ec->seq_end ();
    } else {
        ec->union_begin();
        {
          CORBA::GIOP::AddressingDisposition kind =
            obj->_ior_fwd()->addressing_disposition();

          if (kind == CORBA::GIOP::KeyAddr) {
            ec->put_short (kind);
            ec->seq_begin (objkeylen);
            ec->put_octets (objkey, objkeylen);
            ec->seq_end ();
          }
          else if (kind == CORBA::GIOP::ProfileAddr) {
            ec->put_short (kind);
            prof->encode (*ec);
          }
          else if (kind == CORBA::GIOP::ReferenceAddr) {
            ec->put_short (kind);
            ec->put_ulong (active_index);
            obj->_ior_fwd()->encode (*ec);
          }
          else {
            ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 394, __PRETTY_FUNCTION__), 0)));
          }
        }
        ec->union_end();
    }
}

CORBA::Boolean
MICO::GIOPCodec::put_args (GIOPOutContext &out, CORBA::ORBRequest *req,
                           CORBA::Boolean inp)
{
    CORBA::DataEncoder *ec = out.ec();

    ec->struct_begin ();
    {
        if (inp) {
            if (!req->get_in_args (ec))
                return 0;
        } else {
            CORBA::Boolean is_except;
            if (!req->get_out_args (ec, is_except))
                return 0;
        }
    }
    ec->struct_end ();
    return 1;
}

void
MICO::GIOPCodec::put_size (GIOPOutContext &out, CORBA::ULong key)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong end_pos = ec->buffer()->wpos();
    ec->buffer()->wseek_beg (key);
    ec->put_ulong (end_pos - ec->buffer()->rpos() - _headerlen);
    ec->buffer()->wseek_beg (end_pos);
}

CORBA::Boolean
MICO::GIOPCodec::put_invoke_request (GIOPOutContext &out,
                                     CORBA::ULong req_id,
                                     CORBA::Octet response_flags,
                                     CORBA::Object_ptr obj,
                                     CORBA::ORBRequest *req,
                                     CORBA::Principal_ptr pr)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ByteOrder bo = ec->byteorder();
    if (!strcmp (req->type(), "giop"))
        ec->byteorder (((GIOPRequest *)req)->input_byteorder());

    CORBA::ULong key = put_header (out, CORBA::GIOP::Request);

    CORBA::Boolean send_codesets;
    if (!_codesets_sent && _conv && _giop_ver >= 0x0101) {
      send_codesets = 1;
      _codesets_sent = 1;
    }
    else {
      send_codesets = 0;
    }

    ec->struct_begin ();
    {
        if (_giop_ver < 0x0102) {
            put_contextlist (out, *req->context(), send_codesets);
            ec->put_ulong (req_id);
            ec->put_boolean (response_flags & 0x01);
            if (_giop_ver != 0x0100)
                ec->put_octets ((CORBA::Octet*)"\0\0\0", 3);
            put_target (out, obj);
            ec->put_string_raw (req->op_name());
            if (pr) {
                ec->put_principal (*pr);
            } else {
                ec->put_principal (CORBA::Principal());
            }
        } else {
            ec->put_ulong (req_id);
            ec->put_octet ((response_flags & 0x1) ? 0x03 : 0);
            ec->put_octets ((CORBA::Octet*)"\0\0\0", 3);
            put_target (out, obj);
            ec->put_string_raw (req->op_name());
            put_contextlist (out, *req->context(), send_codesets);
        }
    }
    ec->struct_end ();

    if (_giop_ver >= 0x0102)
        ec->buffer()->walign (ec->max_alignment());

    if (!put_args (out, req, 1)) {
        ec->byteorder (bo);
        return 0;
    }

    if (!Interceptor::ClientInterceptor::_idle()) {
        CORBA::Environment env;
        ec->buffer()->rseek_rel (_headerlen);
        if (!Interceptor::ClientInterceptor::_exec_output_message (
            ec->buffer(), &env)) {
            ec->byteorder (bo);
            return 0;
        }
        ec->buffer()->rseek_rel (-_headerlen);
    }

    put_size (out, key);

    ec->byteorder (bo);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_invoke_reply_offset (GIOPOutContext &out,
                                          CORBA::ORBRequest *req)
{
    CORBA::DataEncoder *ec = out.ec();

    ec->buffer()->wseek_rel (_headerlen);

    ec->struct_begin ();
    {
        put_contextlist (out, *req->context());
        ec->put_ulong (0);
        ec->enumeration (0);
    }
    ec->struct_end ();

    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_invoke_reply (GIOPOutContext &out,
                                   CORBA::ULong req_id,
                                   CORBA::GIOP::ReplyStatusType stat,
                                   CORBA::Object_ptr obj,
                                   CORBA::ORBRequest *req,
                                   CORBA::GIOP::AddressingDisposition ad)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ByteOrder bo = ec->byteorder();
    if (!strcmp (req->type(), "giop"))
        ec->byteorder (((GIOPRequest *)req)->output_byteorder());

    CORBA::ULong key = put_header (out, CORBA::GIOP::Reply);

    ec->struct_begin ();
    {
        if (_giop_ver < 0x0102) {
            put_contextlist (out, *req->context());
            ec->put_ulong (req_id);
            ec->enumeration ((CORBA::ULong)stat);
        } else {
            ec->put_ulong (req_id);
            ec->enumeration ((CORBA::ULong)stat);
            put_contextlist (out, *req->context());
        }
    }
    ec->struct_end ();

    switch (stat) {
    case CORBA::GIOP::NO_EXCEPTION:
    case CORBA::GIOP::USER_EXCEPTION:
    case CORBA::GIOP::SYSTEM_EXCEPTION:
        if (_giop_ver >= 0x0102) {
            ec->buffer()->walign (ec->max_alignment());
        }
        if (!put_args (out, req, 0)) {
            ec->byteorder (bo);
            return 0;
        }
        break;

    case CORBA::GIOP::LOCATION_FORWARD:
    case CORBA::GIOP::LOCATION_FORWARD_PERM:
        ec->put_ior (*obj->_ior());
        break;

    case CORBA::GIOP::NEEDS_ADDRESSING_MODE:
      ec->put_short (ad);
      break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 581, __PRETTY_FUNCTION__), 0)));
        break;
    }

    if (!Interceptor::ServerInterceptor::_idle()) {
        CORBA::Environment env;
        ec->buffer()->rseek_rel (_headerlen);
        if (!Interceptor::ServerInterceptor::_exec_output_message (
            ec->buffer(), &env)) {
            ec->byteorder (bo);
            return 0;
        }
        ec->buffer()->rseek_rel (-_headerlen);
    }

    put_size (out, key);

    ec->byteorder (bo);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_cancel_request (GIOPOutContext &out, CORBA::ULong req_id)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::CancelRequest);

    ec->struct_begin();
    {
        ec->put_ulong (req_id);
    }
    ec->struct_end();

    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_locate_request (GIOPOutContext &out,
                                     CORBA::ULong req_id,
                                     CORBA::Object_ptr obj)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::LocateRequest);

    ec->struct_begin();
    {
        ec->put_ulong (req_id);
        put_target (out, obj);
    }
    ec->struct_end();

    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_locate_reply (GIOPOutContext &out,
                                   CORBA::ULong req_id,
                                   CORBA::GIOP::LocateStatusType stat,
                                   CORBA::Object_ptr obj,
                                   CORBA::GIOP::AddressingDisposition ad)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::LocateReply);

    ec->struct_begin();
    {
        ec->put_ulong (req_id);
        ec->enumeration ((CORBA::ULong)stat);
    }
    ec->struct_end();

    switch (stat) {
    case CORBA::GIOP::OBJECT_FORWARD:
    case CORBA::GIOP::OBJECT_FORWARD_PERM:
        ec->put_ior (*obj->_ior());
        break;
    case CORBA::GIOP::LOC_NEEDS_ADDRESSING_MODE:
        ec->put_short (ad);
        break;
    }
    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_bind_request (GIOPOutContext &out, CORBA::ULong req_id,
                                   const char *repoid,
                                   const CORBA::ORB::ObjectTag &oid)
{






    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::Request);

    ec->struct_begin ();
    {
        if (_giop_ver < 0x0102) {
            put_contextlist (out, CORBA::IOP::ServiceContextList());
            ec->put_ulong (req_id);
            ec->put_boolean (1);
            if (_giop_ver != 0x0100) {
                ec->put_octets ((CORBA::Octet*)"\0\0\0", 3);
            }
            ec->put_ulong (0);
            ec->put_string ("_bind");
            ec->put_principal (CORBA::Principal());
        } else {
            ec->put_ulong (req_id);
            ec->put_octet (1);
            ec->put_octets ((CORBA::Octet*)"\0\0\0", 3);
            ec->put_short (CORBA::GIOP::KeyAddr);
            ec->put_ulong (0);
            ec->put_string ("_bind");
            put_contextlist (out, CORBA::IOP::ServiceContextList());
        }
    }
    ec->struct_end ();

    if (_giop_ver >= 0x0102)
        ec->buffer()->walign (ec->max_alignment());

    ec->struct_begin ();
    {
        ec->put_string (repoid);
        ec->seq_begin (oid.length());
        if (oid.length() > 0)
            ec->put_octets ((const CORBA::Octet *)&oid[0], oid.length());
        ec->seq_end ();
    }
    ec->struct_end ();

    if (!Interceptor::ClientInterceptor::_idle()) {
        CORBA::Environment env;
        ec->buffer()->rseek_rel (_headerlen);
        if (!Interceptor::ClientInterceptor::_exec_output_message (
            ec->buffer(), &env)) {
            return 0;
        }
        ec->buffer()->rseek_rel (-_headerlen);
    }

    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_bind_reply (GIOPOutContext &out,
                                 CORBA::ULong req_id,
                                 CORBA::GIOP::LocateStatusType stat,
                                 CORBA::Object_ptr obj)
{






    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::Reply);

    ec->struct_begin ();
    {
        if (_giop_ver < 0x0102) {
            put_contextlist (out, CORBA::IOP::ServiceContextList());
            ec->put_ulong (req_id);
            ec->enumeration ((CORBA::ULong)CORBA::GIOP::NO_EXCEPTION);
        } else {
            ec->put_ulong (req_id);
            ec->enumeration ((CORBA::ULong)CORBA::GIOP::NO_EXCEPTION);
            put_contextlist (out, CORBA::IOP::ServiceContextList());
        }
    }
    ec->struct_end ();

    if (_giop_ver >= 0x0102)
        ec->buffer()->walign (ec->max_alignment());

    ec->struct_begin ();
    {
        ec->enumeration ((CORBA::ULong)stat);
        if (stat == CORBA::GIOP::OBJECT_HERE) {
            ec->put_ior (*obj->_ior());
        } else {
            ec->put_ior (CORBA::IOR());
        }
    }
    ec->struct_end ();

    if (!Interceptor::ServerInterceptor::_idle()) {
        CORBA::Environment env;
        ec->buffer()->rseek_rel (_headerlen);
        if (!Interceptor::ServerInterceptor::_exec_output_message (
            ec->buffer(), &env)) {
            return 0;
        }
        ec->buffer()->rseek_rel (-_headerlen);
    }

    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_close_msg (GIOPOutContext &out)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::CloseConnection);
    put_size (out, key);
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::put_error_msg (GIOPOutContext &out)
{
    CORBA::DataEncoder *ec = out.ec();

    CORBA::ULong key = put_header (out, CORBA::GIOP::MessageError);
    put_size (out, key);
    return 1;
}



CORBA::Boolean
MICO::GIOPCodec::get_header (GIOPInContext &in, CORBA::GIOP::MsgType &mt,
                             CORBA::ULong &sz, CORBA::Octet &flags)
{
    CORBA::DataDecoder *dc = in.dc();

    CORBA::Boolean b;
    CORBA::Octet o;
    CORBA::Char c;

    if (!(dc->struct_begin())) return 0;
    {
        if (!(dc->arr_begin())) return 0;
        {
            CORBA::Char magic[5];
            magic[4] = 0;


            if (!(dc->get_chars_raw (magic, 4) && !strcmp ((char*)magic, "GIOP"))) return 0;

        }
        if (!(dc->arr_end())) return 0;

        if (!(dc->struct_begin())) return 0;
        {
            CORBA::Octet min, maj;
            CORBA::UShort ver;

            if (!(dc->get_octet (maj))) return 0;
            if (!(dc->get_octet (min))) return 0;

            ver = ((maj << 8) | min);






            if (ver < _giop_ver) {
              if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
                MICO::Logger::Stream (MICO::Logger::GIOP)
                  << "GIOP: peer requests GIOP version "
                  << (int) maj << "." << (int) min
                  << " instead of "
                  << (_giop_ver>>8) << "." << (_giop_ver&255)
                  << ", downgrading." << endl;
              }
              _giop_ver = ver;
            }
            else if (ver > _giop_ver) {
              if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
                MICO::Logger::Stream (MICO::Logger::GIOP)
                  << "GIOP: peer sends message using unsupported GIOP version "
                  << (int) maj << "." << (int) min
                  << endl;
              }
              return 0;
            }
        }
        if (!(dc->struct_end())) return 0;

        if (_giop_ver == 0x0100) {
            if (!(dc->get_boolean (b))) return 0;
            dc->byteorder (b ? CORBA::LittleEndian
                           : CORBA::BigEndian);
            flags = b ? 1 : 0;
        } else {
            if (!(dc->get_octet (flags))) return 0;
            dc->byteorder ((flags & 1) ? CORBA::LittleEndian
                           : CORBA::BigEndian);
        }
        if (!(dc->get_octet (o))) return 0;
        mt = (CORBA::GIOP::MsgType)o;
        if (!(dc->get_ulong (sz))) return 0;
    }
    if (!(dc->struct_end())) return 0;
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_contextlist (GIOPInContext &in,
                                  CORBA::IOP::ServiceContextList &ctx,
                                  CORBA::Boolean codesets)
{
    CORBA::DataDecoder *dc = in.dc();

    CORBA::Codeset::CodesetId csid = 0, wcsid = 0;
    CORBA::Boolean got_codeset_context = 0;

    CORBA::ULong len;
    CORBA::DataDecoder::EncapsState state;
    if (!(dc->seq_begin (len))) return 0;
    ctx.length (len);
    {
        CORBA::ULong context_id;
        for (CORBA::ULong i = 0; i < ctx.length(); ) {
            if (!(dc->struct_begin())) return 0;
            {
                if (!(dc->get_ulong (context_id))) return 0;
                if (context_id == CORBA::IOP::CodeSets) {
                    if (!(dc->encaps_begin (state, len))) return 0;

                    ctx.length (ctx.length()-1);
                    if (!(dc->struct_begin())) return 0;
                    {
                        if (!(dc->get_ulong (csid))) return 0;
                        if (!(dc->get_ulong (wcsid))) return 0;
                    }
                    if (!(dc->struct_end())) return 0;
                    if (!(dc->encaps_end (state))) return 0;

                    got_codeset_context = 1;

                    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
                      MICO::Logger::Stream (MICO::Logger::GIOP)
                        << "GIOP: incoming CodeSets context" << endl;

                      if (CORBA::Codeset::_find_info(csid)) {
                        MICO::Logger::Stream (MICO::Logger::GIOP)
                          << "GIOP:   requested TCS-C is "
                          << CORBA::Codeset::_find_info(csid)->desc << endl;
                      }
                      else {
                        MICO::Logger::Stream (MICO::Logger::GIOP)
                          << "GIOP:   unknown requested TCS-C: "
                          << csid << endl;
                      }

                      if (CORBA::Codeset::_find_info(wcsid)) {
                        MICO::Logger::Stream (MICO::Logger::GIOP)
                          << "GIOP:   requested TCS-W is "
                          << CORBA::Codeset::_find_info(wcsid)->desc << endl;
                      }
                      else {
                        MICO::Logger::Stream (MICO::Logger::GIOP)
                          << "GIOP:   unknown requested TCS-W: "
                          << wcsid << endl;
                      }
                    }
                } else {



                    if (!(dc->seq_begin (len))) return 0;
                    ctx[i].context_id = context_id;
                    ctx[i].context_data.length (len);
                    if (len > 0) {
                        if (!(dc->get_octets ( &ctx[i].context_data[0], ctx[i].context_data.length()))) return 0;


                    }
                    if (!(dc->seq_end ())) return 0;
                    ++i;
                }
            }
            if (!(dc->struct_end())) return 0;
        }
    }
    if (!(dc->seq_end ())) return 0;


    if (codesets) {
      if (got_codeset_context) {



        if (_conv != 0) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: codesets already set up, ignoring codeset context"
              << endl;
          }
        }
        else if (_giop_ver == 0x0100) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: ignoring codeset context on GIOP 1.0 connection,"
              << " assuming ISO 8859-1" << endl;
            _conv = new MICO::GIOP_1_0_CodeSetCoder ();
            in.converters (_conv);
            _dc_proto->converter (_conv, 0);
            _ec_proto->converter (_conv, 0);
          }
        }
        else if (CORBA::Codeset::disabled()) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: ignoring codeset context because of -ORBNoCodesets"
              << endl;
          }
        }
        else {

          if (_giop_ver == 0x0101) {
            _conv = new MICO::GIOP_1_1_CodeSetCoder (csid);
          }
          else if (_giop_ver >= 0x0102) {
            _conv = new MICO::GIOP_1_2_CodeSetCoder (csid, wcsid);
          }

          if (!_conv->isok()) {
            if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
              MICO::Logger::Stream (MICO::Logger::GIOP)
                << "GIOP: cannot setup codeset converter" << endl;
            }

            return 0;
          }

          _csid = csid;
          _wcsid = wcsid;

          in.converters (_conv);
          _dc_proto->converter (_conv, 0);
          _ec_proto->converter (_conv, 0);
        }
      }
      else {





        if (!_conv) {
          if (_giop_ver == 0x0100) {
            _conv = new MICO::GIOP_1_0_CodeSetCoder ();
            in.converters (_conv);
            _dc_proto->converter (_conv, 0);
            _ec_proto->converter (_conv, 0);
          }
          else {
            if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
              MICO::Logger::Stream (MICO::Logger::GIOP)
                << "GIOP: expected codeset context, but didn't get any"
                << endl;
            }
            _conv = new MICO::GIOP_1_0_CodeSetCoder ();
            in.converters (_conv);
            _dc_proto->converter (_conv, 0);
            _ec_proto->converter (_conv, 0);
          }
        }
      }
    }
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_target (GIOPInContext &in, CORBA::Object_ptr obj)
{
    CORBA::DataDecoder *dc = in.dc();

    if (_giop_ver < 0x0102) {
        CORBA::ULong objkeylen;
        CORBA::Octet *objkey;

        obj->_ior()->add_profile (new GIOPSimpleProf);

        if (!(dc->seq_begin (objkeylen))) return 0;
        if (!(dc->buffer()->length() >= objkeylen)) return 0;
        objkey = dc->buffer()->data();
        dc->buffer()->rseek_rel (objkeylen);
        if (!(dc->seq_end ())) return 0;

        obj->_ior()->objectkey (objkey, objkeylen);
    } else {
        if (!(dc->union_begin())) return 0;
        {
            CORBA::GIOP::AddressingDisposition kind;
            if (!(dc->get_short (kind))) return 0;
            if (kind == CORBA::GIOP::KeyAddr) {
                obj->_ior()->add_profile (new GIOPSimpleProf);

                CORBA::ULong objkeylen;
                CORBA::Octet *objkey;

                if (!(dc->seq_begin (objkeylen))) return 0;
                if (!(dc->buffer()->length() >= objkeylen)) return 0;
                objkey = dc->buffer()->data();
                dc->buffer()->rseek_rel (objkeylen);
                if (!(dc->seq_end ())) return 0;

                obj->_ior()->objectkey (objkey, objkeylen);
            } else if (kind == CORBA::GIOP::ProfileAddr) {
                CORBA::IORProfile *prof = CORBA::IORProfile::decode (*dc);
                if (!(prof)) return 0;
                obj->_ior()->add_profile (prof);
            } else if (kind == CORBA::GIOP::ReferenceAddr) {
                if (!(dc->struct_begin())) return 0;
                {
                    CORBA::ULong index;
                    if (!(dc->get_ulong (index))) return 0;
                    if (!(dc->get_ior (*obj->_ior()))) return 0;
                }
                if (!(dc->struct_end())) return 0;
            } else {
                return 0;
            }
        }
        if (!(dc->union_end())) return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::check_header (GIOPInContext &in, CORBA::GIOP::MsgType &mt,
                               CORBA::ULong &sz, CORBA::Octet &flags)
{
    CORBA::ULong pos = in.dc()->buffer()->rpos ();
    CORBA::Boolean ret = get_header (in, mt, sz, flags);
    in.dc()->buffer()->rseek_beg (pos);
    return ret;
}

CORBA::Boolean
MICO::GIOPCodec::get_invoke_request (GIOPInContext &in,
                                     CORBA::ULong &req_id,
                                     CORBA::Octet &response_flags,
                                     CORBA::Object_ptr obj,
                                     CORBA::ORBRequest * &req,
                                     CORBA::Principal_ptr pr)
{
    CORBA::DataDecoder *dc = in.dc();

    if (!Interceptor::ServerInterceptor::_idle()) {
        CORBA::Environment env;
        if (!Interceptor::ServerInterceptor::_exec_input_message (
            dc->buffer(), &env)) {
            return 0;
        }
    }

    CORBA::String_var opname;
    CORBA::IOP::ServiceContextList ctx;

    if (!(dc->struct_begin ())) return 0;
    {
        if (_giop_ver < 0x0102) {
            if (!(get_contextlist (in, ctx, 1))) return 0;
            if (!(dc->get_ulong (req_id))) return 0;
            if (!(dc->get_boolean (response_flags))) return 0;
            if (_giop_ver != 0x0100) {
                CORBA::Octet o[3];
                if (!(dc->get_octets (o, 3))) return 0;
            }
            if (!(get_target (in, obj))) return 0;
            if (!(dc->get_string_raw (opname.out()))) return 0;
            if (!(dc->get_principal (*pr))) return 0;
        } else {
            if (!(dc->get_ulong (req_id))) return 0;
            if (!(dc->get_octet (response_flags))) return 0;

            response_flags = (response_flags & 0x02) ? 1 : 0;
            CORBA::Octet o[3];
            if (!(dc->get_octets (o, 3))) return 0;
            if (!(get_target (in, obj))) return 0;
            if (!(dc->get_string_raw (opname.out()))) return 0;
            if (!(get_contextlist (in, ctx, 1))) return 0;
        }
    }
    if (!(dc->struct_end ())) return 0;

    if (_giop_ver >= 0x0102)

        dc->buffer()->ralign (dc->max_alignment());

    req = new GIOPRequest (opname, in._retn(), this);
    req->context (&ctx);

    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_invoke_reply1 (GIOPInContext &in,
                                    CORBA::ULong &req_id,
                                    CORBA::GIOP::ReplyStatusType &stat,
                                    CORBA::IOP::ServiceContextList &ctx)
{
    CORBA::DataDecoder *dc = in.dc();

    if (!Interceptor::ClientInterceptor::_idle()) {
        CORBA::Environment env;
        if (!Interceptor::ClientInterceptor::_exec_input_message (
            dc->buffer(), &env)) {
            return 0;
        }
    }

    CORBA::ULong k;

    if (!(dc->struct_begin ())) return 0;
    {
        if (_giop_ver < 0x0102) {
            if (!(get_contextlist (in, ctx))) return 0;
            if (!(dc->get_ulong (req_id))) return 0;
            if (!(dc->enumeration (k))) return 0;
            stat = (CORBA::GIOP::ReplyStatusType)k;
        } else {
            if (!(dc->get_ulong (req_id))) return 0;
            if (!(dc->enumeration (k))) return 0;
            stat = (CORBA::GIOP::ReplyStatusType)k;
            if (!(get_contextlist (in, ctx))) return 0;
        }
    }
    if (!(dc->struct_end ())) return 0;

    if (_giop_ver >= 0x0102)

        dc->buffer()->ralign (dc->max_alignment());

    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_invoke_reply2 (GIOPInContext &in,
                                    CORBA::ULong req_id,
                                    CORBA::GIOP::ReplyStatusType stat,
                                    CORBA::Object_ptr &obj,
                                    CORBA::ORBRequest *req,
                                    CORBA::GIOP::AddressingDisposition &ad,
                                    CORBA::IOP::ServiceContextList &ctx)
{
    CORBA::DataDecoder *dc = in.dc();

    obj = CORBA::Object::_nil();

    switch (stat) {
    case CORBA::GIOP::NO_EXCEPTION:
        if (req) {

            req->context (&ctx);
            return req->set_out_args (dc, 0);
        }
        break;

    case CORBA::GIOP::USER_EXCEPTION:
    case CORBA::GIOP::SYSTEM_EXCEPTION:
        if (req) {

            req->context (&ctx);
            return req->set_out_args (dc, 1);
        }
        break;

    case CORBA::GIOP::LOCATION_FORWARD:
    case CORBA::GIOP::LOCATION_FORWARD_PERM: {
        CORBA::IOR *ior = new CORBA::IOR ("", CORBA::IOR::IORProfileVec());
        if (!(dc->get_ior (*ior))) return 0;
        CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
        obj = orb->ior_to_object (ior);
        break;
    }
    case CORBA::GIOP::NEEDS_ADDRESSING_MODE: {
        if (!(dc->get_short (ad))) return 0;
        break;
    }
    default: {
      return 0;
      break;
    }
    }
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_cancel_request (GIOPInContext &in, CORBA::ULong &req_id)
{
    CORBA::DataDecoder *dc = in.dc();

    if (!(dc->struct_begin())) return 0;
    {
        if (!(dc->get_ulong (req_id))) return 0;
    }
    if (!(dc->struct_end())) return 0;
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_locate_request (GIOPInContext &in,
                                     CORBA::ULong &req_id,
                                     CORBA::Object_ptr obj)
{
    CORBA::DataDecoder *dc = in.dc();

    if (!(dc->struct_begin())) return 0;
    {
        if (!(dc->get_ulong (req_id))) return 0;
        if (!(get_target (in, obj))) return 0;
    }
    if (!(dc->struct_end())) return 0;
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_locate_reply (GIOPInContext &in,
                                   CORBA::ULong &req_id,
                                   CORBA::GIOP::LocateStatusType &stat,
                                   CORBA::Object_ptr &obj,
                                   CORBA::GIOP::AddressingDisposition &ad)
{
    CORBA::DataDecoder *dc = in.dc();

    CORBA::ULong k;

    if (!(dc->struct_begin())) return 0;
    {
        if (!(dc->get_ulong (req_id))) return 0;
        if (!(dc->enumeration (k))) return 0;
        stat = (CORBA::GIOP::LocateStatusType)k;
    }
    if (!(dc->struct_end())) return 0;

    switch (stat) {
    case CORBA::GIOP::OBJECT_FORWARD:
    case CORBA::GIOP::OBJECT_FORWARD_PERM: {
        CORBA::IOR *ior = new CORBA::IOR;
        if (!(dc->get_ior (*ior))) return 0;
        CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
        obj = orb->ior_to_object (ior);
        break;
    }
    case CORBA::GIOP::LOC_SYSTEM_EXCEPTION: {
        CORBA::Exception *ex = CORBA::Exception::_decode (*dc);
        if (!(ex)) return 0;

        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1341, __PRETTY_FUNCTION__), 0)));
        break;
    }
    case CORBA::GIOP::LOC_NEEDS_ADDRESSING_MODE: {
        if (!(dc->get_short (ad))) return 0;
        break;
    }
    default:
        obj = CORBA::Object::_nil();
        break;
    }
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_bind_request (GIOPInContext &in, CORBA::String_out repoid,
                                   CORBA::ORB::ObjectTag &oid)
{
# 1367 "iop.cc"
    CORBA::DataDecoder *dc = in.dc();

    if (!(dc->struct_begin ())) return 0;
    {
        if (!(dc->get_string (repoid))) return 0;
        CORBA::ULong l;
        if (!(dc->seq_begin (l))) return 0;
        oid.length (l);
        if (l > 0)
            if (!(dc->get_octets (&oid[0], oid.length()))) return 0;
        if (!(dc->seq_end ())) return 0;
    }
    if (!(dc->struct_end ())) return 0;

    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_bind_reply (GIOPInContext &in,
                                 CORBA::GIOP::LocateStatusType &stat,
                                 CORBA::Object_ptr &obj)
{
# 1397 "iop.cc"
    CORBA::DataDecoder *dc = in.dc();

    CORBA::ULong k;
    CORBA::IOR ior;

    obj = CORBA::Object::_nil();

    if (!(dc->struct_begin ())) return 0;
    {
        if (!(dc->enumeration (k))) return 0;
        stat = (CORBA::GIOP::LocateStatusType)k;
        if (!(dc->get_ior (ior))) return 0;
    }
    if (!(dc->struct_end ())) return 0;

    CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
    obj = orb->ior_to_object (new CORBA::IOR (ior));
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_close_msg (GIOPInContext &in)
{
    CORBA::DataDecoder *dc = in.dc();
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_error_msg (GIOPInContext &in)
{
    CORBA::DataDecoder *dc = in.dc();
    return 1;
}

CORBA::Boolean
MICO::GIOPCodec::get_fragment_header (GIOPInContext &in, CORBA::ULong &req_id,
                                      CORBA::Boolean &has_id)
{
    CORBA::DataDecoder *dc = in.dc();

    if (_giop_ver < 0x0102) {
        has_id = 0;
        return 1;
    }

    if (!(dc->get_ulong (req_id))) return 0;
    has_id = 1;
    return 1;
}







MICO::GIOPRequest::GIOPRequest (const char *op, CORBA::DataDecoder *indata,
                                GIOPCodec *c)
{
    _codec = GIOPCodec::_duplicate (c);

    CORBA::CodeSetCoder *conv = indata->converter();
    CORBA::CodeSetCoder *rconv = conv;

    _opname = op;
    _idc = indata;
    _istart = _idc->buffer()->rpos();

    _oec = _idc->encoder (&_obuf, 0, rconv, 0);
    _ostart = 0;
    _is_except = 0;
}

MICO::GIOPRequest::~GIOPRequest ()
{
    CORBA::release (_codec);
    delete _idc;
    delete _oec;
}

const char *
MICO::GIOPRequest::op_name()
{
    return _opname.c_str();
}

CORBA::Boolean
MICO::GIOPRequest::get_in_args (CORBA::NVList_ptr iparams,
                                CORBA::Context_ptr &ctx)
{
    _idc->buffer()->rseek_beg (_istart);

    if (iparams->count() == 0 && _idc->buffer()->length() == 0)
        return 1;

    CORBA::Any *a;
    CORBA::TypeCode_var tc;
    CORBA::Boolean ret;


    CORBA::DataDecoder::ValueState vstate;
    _idc->valuestate (&vstate, 0);

    for (CORBA::ULong i = 0; i < iparams->count(); ++i) {
        if (iparams->item(i)->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            a = iparams->item(i)->value();
            tc = a->type();
            ret = a->demarshal (tc, *_idc);
            if (!ret) {
                _idc->valuestate (0);
                return 0;
            }
        }
    }
    if (_idc->buffer()->length() > 0) {
        ctx = new CORBA::Context ("");
        if (!_idc->get_context (*ctx)) {
            CORBA::release (ctx);
            ctx = CORBA::Context::_nil();
        }
    }
    _idc->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::get_in_args (StaticAnyList *iparams,
                                CORBA::Context_ptr &ctx)
{
    _idc->buffer()->rseek_beg (_istart);

    if (iparams->size() == 0 && _idc->buffer()->length() == 0)
        return 1;

    CORBA::Boolean ret;


    CORBA::DataDecoder::ValueState vstate;
    _idc->valuestate (&vstate, 0);

    for (mico_vec_size_type i = 0; i < iparams->size(); ++i) {
        if ((*iparams)[i]->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            ret = (*iparams)[i]->demarshal (*_idc);
            if (!ret) {
                _idc->valuestate (0);
                return 0;
            }
        }
    }
    if (_idc->buffer()->length() > 0) {
        ctx = new CORBA::Context ("");
        if (!_idc->get_context (*ctx)) {
            CORBA::release (ctx);
            ctx = CORBA::Context::_nil();
        }
    }
    _idc->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::get_in_args (CORBA::DataEncoder *ec)
{

    ((void) ((!strcmp (ec->type(), _idc->type())) ? 0 : (__assert_fail ("!strcmp (ec->type(), _idc->type())", "iop.cc", 1561, __PRETTY_FUNCTION__), 0)));
    ((void) ((ec->byteorder() == _idc->byteorder()) ? 0 : (__assert_fail ("ec->byteorder() == _idc->byteorder()", "iop.cc", 1562, __PRETTY_FUNCTION__), 0)));

    _idc->buffer()->rseek_beg (_istart);
    ec->put_octets (_idc->buffer()->data(), _idc->buffer()->length());
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::get_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams,
                                 CORBA::Exception *&except)
{
# 1617 "iop.cc"
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1617, __PRETTY_FUNCTION__), 0)));

    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::get_out_args (CORBA::StaticAny *res,
                                 StaticAnyList *oparams,
                                 CORBA::Exception *&except)
{
# 1663 "iop.cc"
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1663, __PRETTY_FUNCTION__), 0)));

    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::get_out_args (CORBA::DataEncoder *ec, CORBA::Boolean &is_ex)
{

    ((void) ((!strcmp (ec->type(), _oec->type())) ? 0 : (__assert_fail ("!strcmp (ec->type(), _oec->type())", "iop.cc", 1672, __PRETTY_FUNCTION__), 0)));
    ((void) ((ec->byteorder() == _oec->byteorder()) ? 0 : (__assert_fail ("ec->byteorder() == _oec->byteorder()", "iop.cc", 1673, __PRETTY_FUNCTION__), 0)));

    _oec->buffer()->rseek_beg (_ostart);
    ec->put_octets (_oec->buffer()->data(), _oec->buffer()->length());
    is_ex = _is_except;

    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::set_out_args (CORBA::Any *res, CORBA::NVList_ptr oparams)
{
    _is_except = 0;
    _oec->buffer()->reset();

    if (!res && oparams->count() == 0)
        return 1;

    if (_codec->version() < 0x0102) {

        GIOPOutContext out (_oec);
        _codec->put_invoke_reply_offset (out, this);
        _ostart = _oec->buffer()->wpos();
    }
    _oec->buffer()->rseek_beg (_ostart);


    CORBA::DataEncoder::ValueState vstate;
    _oec->valuestate (&vstate, 0);

    if (res) {
        if (!res->marshal (*_oec))
            return 0;
    }
    for (CORBA::ULong i = 0; i < oparams->count(); ++i) {
        if (oparams->item(i)->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            if (!oparams->item(i)->value()->marshal (*_oec))
                return 0;
        }
    }
    _oec->valuestate (0);
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::set_out_args (CORBA::StaticAny *res,
                                 StaticAnyList *oparams)
{
    _is_except = 0;
    _oec->buffer()->reset();

    if (!res && oparams->size() == 0)
        return 1;

    if (_codec->version() < 0x0102) {

        GIOPOutContext out (_oec);
        _codec->put_invoke_reply_offset (out, this);
        _ostart = _oec->buffer()->wpos();
    }
    _oec->buffer()->rseek_beg (_ostart);


    CORBA::DataEncoder::ValueState vstate;
    _oec->valuestate (&vstate, 0);

    if (res) {
        if (!res->marshal (*_oec))
            return 0;
    }
    for (mico_vec_size_type i = 0; i < oparams->size(); ++i) {
        if ((*oparams)[i]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            if (!(*oparams)[i]->marshal (*_oec))
                return 0;
        }
    }
    _oec->valuestate (0);
    return 1;
}

void
MICO::GIOPRequest::set_out_args (CORBA::Exception *except)
{
    _oec->buffer()->reset();

    if (_codec->version() < 0x0102) {

        GIOPOutContext out (_oec);
        _codec->put_invoke_reply_offset (out, this);
        _ostart = _oec->buffer()->wpos();
    }
    _oec->buffer()->rseek_beg (_ostart);


    CORBA::DataEncoder::ValueState vstate;
    _oec->valuestate (&vstate, 0);

    _is_except = 1;
    except->_encode (*_oec);

    _oec->valuestate (0);
}

CORBA::Boolean
MICO::GIOPRequest::set_out_args (CORBA::DataDecoder *dc, CORBA::Boolean is_ex)
{
    _oec->buffer()->reset();

    if (_codec->version() < 0x0102) {

        GIOPOutContext out (_oec);
        _codec->put_invoke_reply_offset (out, this);
        _ostart = _oec->buffer()->wpos();
    }
    _oec->buffer()->rseek_beg (_ostart);


    ((void) ((!strcmp (dc->type(), _oec->type())) ? 0 : (__assert_fail ("!strcmp (dc->type(), _oec->type())", "iop.cc", 1790, __PRETTY_FUNCTION__), 0)));
    ((void) ((dc->byteorder() == _oec->byteorder()) ? 0 : (__assert_fail ("dc->byteorder() == _oec->byteorder()", "iop.cc", 1791, __PRETTY_FUNCTION__), 0)));

    _oec->put_octets (dc->buffer()->data(), dc->buffer()->length());
    dc->buffer()->rseek_rel (dc->buffer()->length());
    _is_except = is_ex;
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::copy_out_args (CORBA::ORBRequest *req)
{
    if (this == req)
        return 1;


    copy_svc (req);

    ((void) ((_oec) ? 0 : (__assert_fail ("_oec", "iop.cc", 1808, __PRETTY_FUNCTION__), 0)));

    _oec->buffer()->reset();

    if (_codec->version() < 0x0102) {

        GIOPOutContext out (_oec);
        _codec->put_invoke_reply_offset (out, this);
        _ostart = _oec->buffer()->wpos();
    }
    _oec->buffer()->rseek_beg (_ostart);

    req->get_out_args (_oec, _is_except);
    return 1;
}

CORBA::Boolean
MICO::GIOPRequest::copy_in_args (CORBA::ORBRequest *req)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1827, __PRETTY_FUNCTION__), 0)));
    return 0;
}

const char *
MICO::GIOPRequest::type ()
{
    return "giop";
}

CORBA::ByteOrder
MICO::GIOPRequest::input_byteorder ()
{
    return _idc->byteorder();
}

CORBA::ByteOrder
MICO::GIOPRequest::output_byteorder ()
{
    return _oec->byteorder();
}

CORBA::CodeSetCoder *
MICO::GIOPRequest::converter ()
{
    return _idc->converter();
}




MICO::GIOPSimpleProf::GIOPSimpleProf ()
    : _objkey (0), _length (0)
{
}

MICO::GIOPSimpleProf::GIOPSimpleProf (const GIOPSimpleProf &p)
    : _objkey (0), _length (0)
{
    if (p._objkey) {
        _objkey = new CORBA::Octet[_length = p._length];
        memcpy (_objkey, p._objkey, p._length);
    }
}

MICO::GIOPSimpleProf::~GIOPSimpleProf ()
{
    if (_objkey)
        delete[] _objkey;
}

MICO::GIOPSimpleProf &
MICO::GIOPSimpleProf::operator= (const GIOPSimpleProf &p)
{
    if (this != &p)
        objectkey (p._objkey, p._length);
    return *this;
}

void
MICO::GIOPSimpleProf::encode (CORBA::DataEncoder &) const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1889, __PRETTY_FUNCTION__), 0)));
}

const CORBA::Address *
MICO::GIOPSimpleProf::addr () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 1895, __PRETTY_FUNCTION__), 0)));
    return 0;
}

CORBA::IORProfile::ProfileId
MICO::GIOPSimpleProf::id () const
{
    return 10000;
}

CORBA::IORProfile::ProfileId
MICO::GIOPSimpleProf::encode_id () const
{
    return 10000;
}

void
MICO::GIOPSimpleProf::objectkey (CORBA::Octet *o, CORBA::Long l)
{
    if (_objkey)
        delete[] _objkey;
    _objkey = new CORBA::Octet[_length = l];
    memcpy (_objkey, o, l);
}

const CORBA::Octet *
MICO::GIOPSimpleProf::objectkey (CORBA::Long &l) const
{
    l = _length;
    if (!_objkey)
        return (const CORBA::Octet *)"";
    return _objkey;
}

CORBA::Boolean
MICO::GIOPSimpleProf::reachable ()
{
    return 1;
}

void
MICO::GIOPSimpleProf::print (ostream &o) const
{
  o << "GIOP Simple Profile" << endl;
}

CORBA::IORProfile *
MICO::GIOPSimpleProf::clone () const
{
    return new GIOPSimpleProf (*this);
}

CORBA::Long
MICO::GIOPSimpleProf::compare (const CORBA::IORProfile &p) const
{
    if (p.id() != id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();
    const GIOPSimpleProf &gp = (const GIOPSimpleProf &)p;
    if (_length != gp._length)
        return (CORBA::Long)_length - (CORBA::Long)gp._length;
    return mico_key_compare (_objkey, gp._objkey, _length);
}

CORBA::Boolean
MICO::GIOPSimpleProf::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::GIOPSimpleProf::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}





MICO::GIOPConn::GIOPConn (CORBA::ORB_ptr orb, CORBA::Transport *transp,
                          GIOPConnCallback *cb, GIOPCodec *codec,
                          CORBA::Long tmout)
    : _inctx (codec, new CORBA::Buffer())
{
    _disp = orb->dispatcher();
    _orb = orb;
    _transp = transp;
    _cb = cb;

    _codec = codec;

    _inbuf = new CORBA::Buffer;
    _inlen = _codec->header_length ();
    _inflags = 0;
    _infrag = 0;
    _inbufs = 0;

    _refcnt = 0;
    _idle_tmout = tmout;
    _have_tmout = 0;
    _have_wselect = 0;

    _transp->block (MICO::IIOPProxy::isblocking());
    _transp->rselect (_disp, this);

    check_idle ();
}

MICO::GIOPConn::~GIOPConn ()
{
    ((void) ((_refcnt >= 0) ? 0 : (__assert_fail ("_refcnt >= 0", "iop.cc", 2005, __PRETTY_FUNCTION__), 0)));

    list<CORBA::Buffer *>::iterator i;
    for (i = _outbufs.begin(); i != _outbufs.end(); ++i)
        delete *i;

    _disp->remove (this, CORBA::Dispatcher::Timer);
    _transp->rselect (_disp, 0);
    _transp->wselect (_disp, 0);
    delete _transp;
    delete _inbuf;
    CORBA::release (_codec);


}

void
MICO::GIOPConn::do_read ()
{
    while (42) {
        ((void) ((_inlen > 0) ? 0 : (__assert_fail ("_inlen > 0", "iop.cc", 2025, __PRETTY_FUNCTION__), 0)));
        CORBA::Long r = _transp->read (*_inbuf, _inlen);

        if (r < 0) {
# 2037 "iop.cc"
            r = _transp->read (*_inbuf, _inlen);
        }

        if (r < 0 || (r == 0 && _transp->eof())) {

            _transp->rselect (_disp, 0);
            _transp->wselect (_disp, 0);
            _cb->callback (this, GIOPConnCallback::Closed);
            break;
        } else if (r > 0) {
            _inlen -= r;
            if (_inbuf->length() == _codec->header_length()) {

                ((void) ((_inlen == 0) ? 0 : (__assert_fail ("_inlen == 0", "iop.cc", 2050, __PRETTY_FUNCTION__), 0)));
                CORBA::GIOP::MsgType mt;
                _inctx.buffer (_inbuf);
                if (!_codec->check_header (_inctx, mt, _inlen, _inflags)) {

                    ((void) ((!_inbufs) ? 0 : (__assert_fail ("!_inbufs", "iop.cc", 2055, __PRETTY_FUNCTION__), 0)));
                    _inbufs = _inbuf;
                    _inbuf = new CORBA::Buffer;
                    _inlen = _codec->header_length ();
                    if (!_cb->callback (this, GIOPConnCallback::InputReady) ||
                        MICO::IIOPProxy::isblocking())
                        break;
                    continue;
                }
                if (mt == CORBA::GIOP::Fragment) {

                    if (_codec->version() >= 0x0102) {

                        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2068, __PRETTY_FUNCTION__), 0)));
                    }
                    ((void) ((_infrag) ? 0 : (__assert_fail ("_infrag", "iop.cc", 2070, __PRETTY_FUNCTION__), 0)));
                    delete _inbuf;
                    _inbuf = _infrag;
                    _infrag = 0;
                }
            }
            if (_inlen == 0) {

                if (_inflags & 2) {

                    ((void) ((!_infrag) ? 0 : (__assert_fail ("!_infrag", "iop.cc", 2080, __PRETTY_FUNCTION__), 0)));
                    _infrag = _inbuf;
                    _inbuf = new CORBA::Buffer;
                    _inlen = _codec->header_length();
                } else {
                    ((void) ((!_inbufs) ? 0 : (__assert_fail ("!_inbufs", "iop.cc", 2085, __PRETTY_FUNCTION__), 0)));
                    _inbufs = _inbuf;
                    _inbuf = new CORBA::Buffer;
                    _inlen = _codec->header_length ();
                    if (!_cb->callback (this, GIOPConnCallback::InputReady) ||
                        MICO::IIOPProxy::isblocking())
                        break;
                }
            }
        } else if (r == 0) {
            break;
        } else {
            ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2097, __PRETTY_FUNCTION__), 0)));
        }
    }
}

void
MICO::GIOPConn::do_write ()
{
    while (42) {
        ((void) ((_outbufs.size() > 0) ? 0 : (__assert_fail ("_outbufs.size() > 0", "iop.cc", 2106, __PRETTY_FUNCTION__), 0)));
        CORBA::Buffer *b = _outbufs.front();
        CORBA::Long r = _transp->write (*b, b->length());
        if (r > 0) {
            if (b->length() == 0) {

                delete b;
                _outbufs.pop_front();
                if (_outbufs.size() == 0) {
                    check_idle ();
                    break;
                }
            }
        } else if (r < 0) {

            _transp->rselect (_disp, 0);
            _transp->wselect (_disp, 0);
            _cb->callback (this, GIOPConnCallback::Closed);
            break;
        } else if (r == 0) {
            break;
        } else {
            ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2128, __PRETTY_FUNCTION__), 0)));
        }
    }
}

void
MICO::GIOPConn::callback (CORBA::Transport *,
                          CORBA::TransportCallback::Event ev)
{
    switch (ev) {
    case Read:
        do_read ();
        break;

    case Write:
        do_write ();
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2147, __PRETTY_FUNCTION__), 0)));
    }
}

void
MICO::GIOPConn::callback (CORBA::Dispatcher *d,
                          CORBA::DispatcherCallback::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Timer:
        _cb->callback (this, GIOPConnCallback::Idle);
        break;
    case CORBA::Dispatcher::Moved:
        _disp = d;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2163, __PRETTY_FUNCTION__), 0)));
    }
}

void
MICO::GIOPConn::check_idle ()
{
    if (_idle_tmout > 0 && _refcnt == 0 && _outbufs.size() == 0) {
        if (_have_tmout)
            _disp->remove (this, CORBA::Dispatcher::Timer);
        _disp->tm_event (this, _idle_tmout);
        _have_tmout = 1;
    }
    if (_have_wselect && _outbufs.size() == 0) {
        _transp->wselect (_disp, 0);
        _have_wselect = 0;
    }
}

void
MICO::GIOPConn::check_busy ()
{
    if (_have_tmout && (_refcnt > 0 || _outbufs.size() > 0)) {
        _disp->remove (this, CORBA::Dispatcher::Timer);
        _have_tmout = 0;
    }
    if (!_have_wselect && _outbufs.size() > 0) {
        _transp->wselect (_disp, this);
        _have_wselect = 1;
    }
}

CORBA::Boolean
MICO::GIOPConn::check_events ()
{
    if (_transp->isreadable()) {
        do_read();
        return 1;
    }
    return 0;
}

void
MICO::GIOPConn::ref ()
{
    ++_refcnt;
    check_busy ();
}

CORBA::Boolean
MICO::GIOPConn::deref (CORBA::Boolean all)
{
    if (all)
        _refcnt = 0;
    else
        --_refcnt;
    check_idle ();
    return (_refcnt <= 0);
}

void
MICO::GIOPConn::output (CORBA::Buffer *b)
{
  if (MICO::Logger::IsLogged (MICO::Logger::Transport)) {
    b->dump ("Out Data", MICO::Logger::Stream (MICO::Logger::Transport));
  }


    if (_outbufs.size() == 0) {
        _transp->write (*b, b->length());
        if (b->length() == 0) {
            delete b;
            return;
        }
        _outbufs.push_back (b);
    } else {
        _outbufs.push_back (b);
        do_write ();
    }
    check_busy ();
}

CORBA::Buffer *
MICO::GIOPConn::input ()
{
    CORBA::Buffer *b = _inbufs;
    _inbufs = 0;

  if (MICO::Logger::IsLogged (MICO::Logger::Transport)) {
    b->dump ("In Data", MICO::Logger::Stream (MICO::Logger::Transport));
  }

    return b;
}

void
MICO::GIOPConn::flush ()
{
    CORBA::Boolean isblock = _transp->isblocking();
    _transp->block (1);
    while (_outbufs.size() > 0) {
        CORBA::Buffer *b = _outbufs.front();
        _outbufs.pop_front();
        int i = _transp->write (*b, b->length());
        delete b;
    }
    _transp->block (isblock);
}

void
MICO::GIOPConn::buffering (CORBA::Boolean dobuffering)
{
    _transp->buffering (dobuffering);
}

void
MICO::GIOPConn::cancel (CORBA::ULong reqid)
{



    ((void) ((!_infrag) ? 0 : (__assert_fail ("!_infrag", "iop.cc", 2284, __PRETTY_FUNCTION__), 0)));
}





CORBA::Boolean MICO::IIOPProxy::_isblocking = 0;

MICO::IIOPProxy::IIOPProxy (CORBA::ORB_ptr orb,
                            CORBA::UShort giop_ver)
{



    _valid_profiles.push_back (CORBA::IORProfile::TAG_INTERNET_IOP);
    _valid_profiles.push_back (CORBA::IORProfile::TAG_UNIX_IOP);
    _valid_profiles.push_back (CORBA::IORProfile::TAG_UDP_IOP);
    _valid_profiles.push_back (CORBA::IORProfile::TAG_SSL_INTERNET_IOP);
    _valid_profiles.push_back (CORBA::IORProfile::TAG_SSL_UNIX_IOP);
    _valid_profiles.push_back (CORBA::IORProfile::TAG_SSL_UDP_IOP);

    _orb = orb;

    _cache_used = 0;
    _cache_rec = new IIOPProxyInvokeRec;

    _giop_ver = giop_ver;
    _orb->register_oa (this);
}

MICO::IIOPProxy::~IIOPProxy ()
{
    _orb->unregister_oa (this);






    for (MapAddrConn::iterator i0 = _conns.begin(); i0 != _conns.end(); ++i0)
        delete (*i0).second;
    for (MapIdConn::iterator i1 = _ids.begin(); i1 != _ids.end(); ++i1)
        delete (*i1).second;

    delete _cache_rec;
}


void
MICO::IIOPProxy::register_profile_id (CORBA::ULong id)
{
    for (ProfIdVec::iterator i = _valid_profiles.begin();
         i != _valid_profiles.end(); ++i) {
        if (*i == id)
            return;
    }
    _valid_profiles.push_back (id);
}

void
MICO::IIOPProxy::unregister_profile_id (CORBA::ULong id)
{
    for (ProfIdVec::iterator i = _valid_profiles.begin();
         i != _valid_profiles.end(); ++i) {
        if (*i == id) {
            _valid_profiles.erase (i);
            break;
        }
    }
}

MICO::IIOPProxyInvokeRec *
MICO::IIOPProxy::create_invoke ()
{
    if (!_cache_used) {
        _cache_used = 1;
        return _cache_rec;
    }

    return new IIOPProxyInvokeRec;
}

MICO::IIOPProxyInvokeRec *
MICO::IIOPProxy::get_invoke (MsgId id)
{
    if (_cache_used && _cache_rec->id() == id)
        return _cache_rec;

    MapIdConn::iterator i = _ids.find (id);
    return i == _ids.end() ? 0 : (*i).second;
}

void
MICO::IIOPProxy::add_invoke (IIOPProxyInvokeRec *rec)
{
    if (_cache_rec == rec)
        return;

    _ids[rec->id()] = rec;
}

void
MICO::IIOPProxy::del_invoke (MsgId id)
{
    if (_cache_used && _cache_rec->id() == id) {
        _cache_rec->free();
        _cache_used = 0;
        return;
    }
    MapIdConn::iterator i = _ids.find (id);
    if (i != _ids.end()) {
        delete (*i).second;
        _ids.erase (i);
    }
}

void
MICO::IIOPProxy::abort_invoke (MsgId id)
{

  if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
    MICO::Logger::Stream (MICO::Logger::IIOP)
      << "GIOP: invocation(" << id << ") aborted" << endl;
  }

    switch (_orb->request_type (id)) {
    case CORBA::RequestInvoke: {
        CORBA::Object_var obj = new CORBA::Object (new CORBA::IOR);
        CORBA::Request_var req =
            new CORBA::Request (obj, "someop");
        LocalRequest orbreq (req);
        orbreq.set_out_args (
            new CORBA::TRANSIENT (0, CORBA::COMPLETED_MAYBE));
        _orb->answer_invoke (id, CORBA::InvokeSysEx,
                             CORBA::Object::_nil(), &orbreq, 0);
        break;
    }
    case CORBA::RequestLocate:
        _orb->answer_locate (id, CORBA::LocateUnknown,
                             CORBA::Object::_nil(), 0);
        break;

    case CORBA::RequestBind:
        _orb->answer_bind (id, CORBA::LocateUnknown,
                           CORBA::Object::_nil());
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2433, __PRETTY_FUNCTION__), 0)));
    }
    del_invoke (id);
}

void
MICO::IIOPProxy::redo_invoke (MsgId id)
{

  if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
    MICO::Logger::Stream (MICO::Logger::IIOP)
      << "GIOP: invocation(" << id << ") redone" << endl;
  }

    del_invoke (id);
    _orb->redo_request (id);
}

MICO::GIOPConn *
MICO::IIOPProxy::make_conn (const CORBA::Address *addr,
                            CORBA::Boolean docreate,
                            CORBA::UShort version)
{
    MapAddrConn::iterator i = _conns.find (addr);
    if (i != _conns.end()) {
# 2467 "iop.cc"
        if ((*i).second->check_events()) {
            while ((i = _conns.find (addr)) != _conns.end()) {
                if (!(*i).second->check_events())
                    return (*i).second;
            }
        } else

            return (*i).second;
    }

    if (!docreate)
        return 0;

    if (version == 0 || version > _giop_ver) {
      version = _giop_ver;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "IIOP: making new GIOP "
        << (version>>8) << "." << (version&255)
        << " connection to " << addr->stringify()
        << endl;
    }

    CORBA::Transport *t = addr->make_transport();
    if (!t->connect (addr)) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "IIOP: connect to " << addr->stringify()
          << " failed: " << t->errormsg() << endl;
      }
      delete t;
      return 0;
    }

    GIOPConn *conn =
        new GIOPConn (_orb, t, this,
                      new GIOPCodec (new CDRDecoder, new CDREncoder,
                                     version),
                      0L );
    _conns[t->peer()] = conn;
    return conn;
}

MICO::GIOPConn *
MICO::IIOPProxy::make_conn (CORBA::Object_ptr obj)
{
    CORBA::IORProfile *prof;
    const CORBA::Address *addr;
    MICO::GIOPConn *conn;





    prof = obj->_ior_fwd()->active_profile();

    if (prof) {
      MapProfConn::iterator i;
      do {
        i = _prof_conns.find (prof);
      }
      while (i != _prof_conns.end() && (*i).second->check_events());





      if (i != _prof_conns.end()) {
        return (*i).second;
      }







      obj->_ior_fwd()->active_profile((CORBA::IORProfile *) 0);
    }
# 2557 "iop.cc"
    if (_prof_conns.size() > 1000) {
      _prof_conns.clear ();
    }






    CORBA::Policy_var policy =
        obj->_get_policy (MICOPolicy::TRANSPORTPREF_POLICY_TYPE);
    MICOPolicy::TransportPrefPolicy_var tpp =
        MICOPolicy::TransportPrefPolicy::_narrow (policy);
    ((void) ((!CORBA::is_nil (tpp)) ? 0 : (__assert_fail ("!CORBA::is_nil (tpp)", "iop.cc", 2570, __PRETTY_FUNCTION__), 0)));

    MICOPolicy::TransportPrefPolicy::ProfileTagSeq *prefs =
        tpp->preferences_nocopy();

    for (CORBA::ULong i = 0; i < prefs->length(); ++i) {
        CORBA::UShort version;
        prof = obj->_ior_fwd()->profile ((*prefs)[i]);
        while (prof) {
            addr = prof->addr ();
            ((void) ((addr) ? 0 : (__assert_fail ("addr", "iop.cc", 2580, __PRETTY_FUNCTION__), 0)));

            version = 0;
            if (prof->id() == CORBA::IORProfile::TAG_INTERNET_IOP) {
              MICO::IIOPProfile * i = (MICO::IIOPProfile *) prof;
              version = i->iiop_version();
            }

            GIOPConn *conn = make_conn (addr, 1, version);
            if (conn) {
              obj->_ior_fwd()->active_profile (prof);
              _prof_conns[prof] = conn;
              return conn;
            }
            prof = obj->_ior_fwd()->profile ((*prefs)[i], 0, prof);
        }
    }
    return 0;
}

void
MICO::IIOPProxy::kill_conn (GIOPConn *conn, CORBA::Boolean redo)
{
    CORBA::Boolean again;

    do {
        again = 0;
        for (MapAddrConn::iterator i = _conns.begin(); i != _conns.end(); ++i) {
            if ((*i).second == conn) {
                _conns.erase (i);
                again = 1;
                break;
            }
        }
    } while (again);

    do {
        again = 0;
        for (MapProfConn::iterator i = _prof_conns.begin();
             i != _prof_conns.end(); ++i) {
            if ((*i).second == conn) {
                _prof_conns.erase (i);
                again = 1;
                break;
            }
        }
    } while (again);



    if (_cache_used && _cache_rec->conn() == conn) {
        if (redo) {
            redo_invoke (_cache_rec->id());
        } else {
            abort_invoke (_cache_rec->id());
        }
    }

    do {
        again = 0;
        IIOPProxyInvokeRec *rec;
        for (MapIdConn::iterator i = _ids.begin(); i != _ids.end(); ++i) {
            rec = (*i).second;
            if (rec->conn() != conn)
                continue;

            if (redo) {
                redo_invoke (rec->id());
            } else {
                abort_invoke (rec->id());
            }
            again = 1;
            break;
        }
    } while (again);
    delete conn;
}

void
MICO::IIOPProxy::conn_error (GIOPConn *conn, CORBA::Boolean send_error)
{
    if (!send_error) {
        kill_conn (conn);
        return;
    }

    GIOPOutContext out (conn->codec());
    conn->codec()->put_error_msg (out);
    conn->output (out._retn());

    conn->deref (1);
}

const char *
MICO::IIOPProxy::get_oaid () const
{
    return "mico-iiop-proxy";
}

CORBA::Boolean
MICO::IIOPProxy::has_object (CORBA::Object_ptr obj)
{
    CORBA::IOR *tmpl = _orb->ior_template();






    for (mico_vec_size_type i = 0; i < _valid_profiles.size(); ++i) {
        CORBA::IORProfile *p1, *p2;
        p1 = obj->_ior_fwd()->profile (_valid_profiles[i]);
        if (p1) {
            p2 = tmpl->profile (_valid_profiles[i]);
            return !p2 || !(*p1 == *p2);
        }
    }
    return 0;
}

CORBA::Boolean
MICO::IIOPProxy::is_local () const
{
    return 0;
}

CORBA::Boolean
MICO::IIOPProxy::invoke (MsgId msgid, CORBA::Object_ptr obj,
                         CORBA::ORBRequest *req,
                         CORBA::Principal_ptr pr, CORBA::Boolean response_exp)
{
    GIOPConn *conn = make_conn (obj);
    if (!conn) {
        CORBA::COMM_FAILURE ex;
        req->set_out_args (&ex);
        _orb->answer_invoke (msgid, CORBA::InvokeSysEx, CORBA::Object::_nil(),
                             req, 0);
        return 0;
    }

    if (!conn->codec()->converter()) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: Codeset negotiation with "
          << conn->transport()->peer()->stringify()
          << " using GIOP version "
          << (conn->codec()->version() >> 8) << "."
          << (conn->codec()->version() & 255) << endl;
      }

      conn->codec()->setup_codeset_ids (obj);
      ((void) ((conn->codec()->converter()) ? 0 : (__assert_fail ("conn->codec()->converter()", "iop.cc", 2731, __PRETTY_FUNCTION__), 0)));
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending Request to "
        << conn->transport()->peer()->stringify()
        << " msgid is " << msgid << endl;
    }

    GIOPOutContext out (conn->codec(), conn->codec()->converter());
    if (!conn->codec()->put_invoke_request (out, msgid, response_exp,
                                            obj, req, pr)) {
        CORBA::MARSHAL ex;
        req->set_out_args (&ex);
        _orb->answer_invoke (msgid, CORBA::InvokeSysEx, CORBA::Object::_nil(),
                             req, 0);
        return 0;
    }

    if (response_exp) {
        conn->ref();
        IIOPProxyInvokeRec *rec = create_invoke();
        rec->init (msgid, conn, req);
        add_invoke (rec);
    }
    conn->buffering (!response_exp);
    conn->output (out._retn());
    if (response_exp && _isblocking)
        conn->do_read ();
    return 1;
}

CORBA::Boolean
MICO::IIOPProxy::bind (MsgId msgid, const char *repoid,
                       const CORBA::ORB::ObjectTag &oid,
                       CORBA::Address *addr)
{
    if (!addr || addr->is_local())
        return 0;

    GIOPConn *conn = make_conn (addr);
    if (!conn) {
        _orb->answer_bind (msgid, CORBA::LocateUnknown, CORBA::Object::_nil());
        return 1;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending _bind Request to "
        << conn->transport()->peer()->stringify()
        << " msgid is " << msgid << endl;
    }

    GIOPOutContext out (conn->codec());
    conn->codec()->put_bind_request (out, msgid, repoid, oid);

    conn->ref();

    IIOPProxyInvokeRec *rec = create_invoke();
    rec->init (msgid, conn);
    add_invoke (rec);

    conn->output (out._retn());
    return 1;
}

CORBA::Boolean
MICO::IIOPProxy::locate (MsgId msgid, CORBA::Object_ptr obj)
{
    GIOPConn *conn = make_conn (obj);
    if (!conn) {
        _orb->answer_locate (msgid, CORBA::LocateUnknown,
                             CORBA::Object::_nil(), 0);
        return 0;
    }

    if (!conn->codec()->converter()) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: Codeset negotiation with "
          << conn->transport()->peer()->stringify()
          << " using GIOP version "
          << (conn->codec()->version() >> 8) << "."
          << (conn->codec()->version() & 255) << endl;
      }

      conn->codec()->setup_codeset_ids (obj);
      ((void) ((conn->codec()->converter()) ? 0 : (__assert_fail ("conn->codec()->converter()", "iop.cc", 2819, __PRETTY_FUNCTION__), 0)));
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending LocateRequest to "
        << conn->transport()->peer()->stringify()
        << " msgid is " << msgid << endl;
    }

    GIOPOutContext out (conn->codec());
    conn->codec()->put_locate_request (out, msgid, obj);

    conn->ref();

    IIOPProxyInvokeRec *rec = create_invoke();
    rec->init (msgid, conn);
    add_invoke (rec);

    conn->output (out._retn());
    return 1;
}

CORBA::Object_ptr
MICO::IIOPProxy::skeleton (CORBA::Object_ptr)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2845, __PRETTY_FUNCTION__), 0)));
    return CORBA::Object::_nil ();
}

void
MICO::IIOPProxy::cancel (MsgId msgid)
{
    IIOPProxyInvokeRec *rec = get_invoke (msgid);
    if (!rec)
        return;

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending Cancel to "
        << rec->conn()->transport()->peer()->stringify()
        << " msgid is " << msgid << endl;
    }

    GIOPOutContext out (rec->conn()->codec());
    rec->conn()->codec()->put_cancel_request (out, msgid);

    rec->conn()->output (out._retn());
    rec->conn()->deref ();

    del_invoke (msgid);
}

void
MICO::IIOPProxy::shutdown (CORBA::Boolean wait_for_completion)
{

    _orb->answer_shutdown (this);
}

void
MICO::IIOPProxy::answer_invoke (CORBA::ULong, CORBA::Object_ptr,
                                CORBA::ORBRequest *, CORBA::InvokeStatus)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2883, __PRETTY_FUNCTION__), 0)));
}

void
MICO::IIOPProxy::exec_invoke_reply (GIOPInContext &in, CORBA::ULong req_id,
                                    CORBA::GIOP::ReplyStatusType stat,
                                    CORBA::Object_ptr obj,
                                    CORBA::ORBRequest *req,
                                    CORBA::GIOP::AddressingDisposition ad,
                                    GIOPConn *conn)
{
    switch (_orb->request_type (req_id)) {
    case CORBA::RequestBind: {

        CORBA::GIOP::LocateStatusType bind_stat;
        CORBA::Object_ptr bind_obj;

        if (stat != CORBA::GIOP::NO_EXCEPTION ||
            !conn->codec()->get_bind_reply (in, bind_stat, bind_obj) ||
            bind_stat != CORBA::GIOP::OBJECT_HERE) {
            _orb->answer_bind (req_id, CORBA::LocateUnknown,
                               CORBA::Object::_nil());
        } else {
            _orb->answer_bind (req_id, CORBA::LocateHere, bind_obj);
            CORBA::release (bind_obj);
        }
        break;
    }
    case CORBA::RequestInvoke: {

        CORBA::InvokeStatus orb_stat = CORBA::InvokeOk;

        switch (stat) {
        case CORBA::GIOP::NO_EXCEPTION:
            orb_stat = CORBA::InvokeOk;
            break;

        case CORBA::GIOP::USER_EXCEPTION:
            orb_stat = CORBA::InvokeUsrEx;
            break;

        case CORBA::GIOP::SYSTEM_EXCEPTION:
            orb_stat = CORBA::InvokeSysEx;
            break;

        case CORBA::GIOP::LOCATION_FORWARD:
        case CORBA::GIOP::LOCATION_FORWARD_PERM:
            orb_stat = CORBA::InvokeForward;
            break;

        case CORBA::GIOP::NEEDS_ADDRESSING_MODE:
            orb_stat = CORBA::InvokeAddrDisp;
            break;

        default:
            ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2938, __PRETTY_FUNCTION__), 0)));
            break;
        }
        _orb->answer_invoke (req_id, orb_stat, obj, req, 0);
        break;
    }
    case CORBA::RequestUnknown:

        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 2948, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::IIOPProxy::handle_invoke_reply (GIOPConn *conn, GIOPInContext &in)
{
    CORBA::ULong req_id;
    CORBA::GIOP::ReplyStatusType stat;
    CORBA::Object_ptr obj = CORBA::Object::_nil();
    CORBA::GIOP::AddressingDisposition ad;
    CORBA::IOP::ServiceContextList ctx;


    if (!conn->codec()->get_invoke_reply1 (in, req_id, stat, ctx)) {
      if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
        MICO::Logger::Stream (MICO::Logger::IIOP)
          << "GIOP: cannot decode incoming Reply from "
          << conn->transport()->peer()->stringify() << endl;
      }
      conn_error (conn);
      return 0;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: incoming Reply from "
        << conn->transport()->peer()->stringify()
        << " for msgid " << req_id
        << " status is " << (CORBA::ULong) stat
        << endl;
    }

    IIOPProxyInvokeRec *rec = get_invoke (req_id);
    if (!rec) {

        return 1;
    }

    in.converters (conn->codec()->converter());

    if (!conn->codec()->get_invoke_reply2 (in, req_id, stat, obj,
                                           rec->request(), ad, ctx)) {
      if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
        MICO::Logger::Stream (MICO::Logger::IIOP)
          << "GIOP: reply marshalling error for msgid " << req_id << endl;
      }
      if (rec->request()) {
        CORBA::MARSHAL ex (0, CORBA::COMPLETED_MAYBE);
        rec->request()->set_out_args (&ex);
        stat = CORBA::GIOP::SYSTEM_EXCEPTION;
      }
    }
    exec_invoke_reply (in, req_id, stat, obj, rec->request(), ad, conn);
    CORBA::release (obj);

    conn->deref();
    del_invoke (req_id);

    return 1;
}

CORBA::Boolean
MICO::IIOPProxy::handle_locate_reply (GIOPConn *conn, GIOPInContext &in)
{
    CORBA::ULong req_id;
    CORBA::GIOP::LocateStatusType stat = CORBA::GIOP::OBJECT_HERE;
    CORBA::LocateStatus orb_stat = CORBA::LocateHere;
    CORBA::Object_ptr obj = CORBA::Object::_nil();
    CORBA::GIOP::AddressingDisposition ad;

    if (!conn->codec()->get_locate_reply (in, req_id, stat, obj, ad)) {
      if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
        MICO::Logger::Stream (MICO::Logger::IIOP)
          << "GIOP: cannot decode LocateReply" << endl;
      }
        conn_error (conn);
        return 0;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: incoming LocateReply from "
        << conn->transport()->peer()->stringify()
        << " for msgid " << req_id
        << " status is " << (CORBA::ULong) stat
        << endl;
    }

    IIOPProxyInvokeRec *rec = get_invoke (req_id);
    if (!rec) {

        return 1;
    }

    switch (stat) {
    case CORBA::GIOP::UNKNOWN_OBJECT:
        orb_stat = CORBA::LocateUnknown;
        break;

    case CORBA::GIOP::OBJECT_HERE:
        orb_stat = CORBA::LocateHere;
        break;

    case CORBA::GIOP::OBJECT_FORWARD:
    case CORBA::GIOP::OBJECT_FORWARD_PERM:
        orb_stat = CORBA::LocateForward;
        break;

    case CORBA::GIOP::LOC_NEEDS_ADDRESSING_MODE:
        orb_stat = CORBA::LocateAddrDisp;
       break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3062, __PRETTY_FUNCTION__), 0)));
        break;
    }
    _orb->answer_locate (req_id, orb_stat, obj, ad);
    CORBA::release (obj);

    conn->deref();
    del_invoke (req_id);

    return 1;
}

CORBA::Boolean
MICO::IIOPProxy::handle_input (GIOPConn *conn)
{
    if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
      MICO::Logger::Stream (MICO::Logger::IIOP)
        << "IIOP: incoming data from "
        << conn->transport()->peer()->stringify() << endl;
    }

    GIOPInContext in (conn->codec(), conn->input());

    CORBA::GIOP::MsgType mt;
    CORBA::ULong size;
    CORBA::Octet flags;


    if (!conn->codec()->get_header (in, mt, size, flags)) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: cannot decode incoming header from "
          << conn->transport()->peer()->stringify() << endl;
      }
      conn_error (conn);
      return 0;
    }

    switch (mt) {
    case CORBA::GIOP::Reply:
      return handle_invoke_reply (conn, in);

    case CORBA::GIOP::LocateReply:
      return handle_locate_reply (conn, in);

    case CORBA::GIOP::CloseConnection:
        if (!conn->codec()->get_close_msg (in)) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: cannot decode CloseConnection from "
              << conn->transport()->peer()->stringify() << endl;
          }
          conn_error (conn);
        } else {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: incoming CloseConnection from "
              << conn->transport()->peer()->stringify() << endl;
          }
          kill_conn (conn, 1);
        }
        return 0;

    case CORBA::GIOP::MessageError:
        if (!conn->codec()->get_error_msg (in)) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: cannot decode MessageError from "
              << conn->transport()->peer()->stringify() << endl;
          }
          conn_error (conn, 0);
          break;
        }
        if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
          MICO::Logger::Stream (MICO::Logger::GIOP)
            << "GIOP: incoming MessageError from "
            << conn->transport()->peer()->stringify() << endl;
        }
        kill_conn (conn);
        return 0;

    default:
        if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
          MICO::Logger::Stream (MICO::Logger::GIOP)
            << "GIOP: bad incoming message type (" << mt << ") from "
            << conn->transport()->peer()->stringify() << endl;
        }
        break;
    }
    return 1;
}

CORBA::Boolean
MICO::IIOPProxy::callback (GIOPConn *conn, GIOPConnCallback::Event ev)
{
    switch (ev) {
    case GIOPConnCallback::InputReady:
        return handle_input (conn);

    case GIOPConnCallback::Idle:
        if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
          MICO::Logger::Stream (MICO::Logger::IIOP)
            << "IIOP: shutting down idle conn to "
            << conn->transport()->peer()->stringify() << endl;
        }
        kill_conn (conn);
        return 0;

    case GIOPConnCallback::Closed:
        if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
          MICO::Logger::Stream (MICO::Logger::IIOP)
            << "IIOP: connection to "
            << conn->transport()->peer()->stringify()
            << " closed or broken" << endl;
        }
        kill_conn (conn);
        return 0;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3181, __PRETTY_FUNCTION__), 0)));
    }
    return 1;
}





MICO::IIOPServerInvokeRec::IIOPServerInvokeRec ()
{
    _conn = 0;
    _req = 0;
    _obj = 0;
    _pr = 0;
}


MICO::IIOPServerInvokeRec::~IIOPServerInvokeRec ()
{
    CORBA::release (_req);
    CORBA::release (_obj);
    CORBA::release (_pr);


}

void
MICO::IIOPServerInvokeRec::free ()
{
    CORBA::release (_req);
    CORBA::release (_obj);
    CORBA::release (_pr);

    _conn = 0;
    _req = 0;
    _obj = 0;
    _pr = 0;
}

void
MICO::IIOPServerInvokeRec::init_invoke (
    GIOPConn *conn, MsgId reqid,
    MsgId orbid, CORBA::ORBRequest *req,
    CORBA::Object_ptr obj,
    CORBA::Principal_ptr pr)
{
    _conn = conn;
    _orbid = orbid;
    _reqid = reqid;
    _req = req;
    _obj = obj;
    _pr = pr;
}

void
MICO::IIOPServerInvokeRec::init_locate (
    GIOPConn *conn, MsgId reqid,
    MsgId orbid, CORBA::Object_ptr obj)
{
    _conn = conn;
    _orbid = orbid;
    _reqid = reqid;
    _req = CORBA::ORBRequest::_nil();
    _obj = obj;
    _pr = CORBA::Principal::_nil();
}





MICO::IIOPServer::IIOPServer (CORBA::ORB_ptr orb, CORBA::UShort iiop_ver)
{
    _orb = orb;

    _cache_used = 0;
    _cache_rec = new IIOPServerInvokeRec;

    _iiop_ver = iiop_ver;


    _orb->register_oa (this);
}

MICO::IIOPServer::~IIOPServer ()
{
    _orb->unregister_oa (this);




    for (ListConn::iterator i0 = _conns.begin(); i0 != _conns.end(); ++i0)
        delete *i0;
    if (_cache_used)
        _orb->cancel (_cache_rec->orbid());
    for (MapIdConn::iterator i1 = _orbids.begin(); i1 != _orbids.end(); ++i1) {
        _orb->cancel ((*i1).first);
        delete (*i1).second;
    }
    for (mico_vec_size_type i2 = 0; i2 < _tservers.size(); ++i2) {
        _tservers[i2]->aselect (_orb->dispatcher(), 0);
        delete _tservers[i2];
    }
}

CORBA::Boolean
MICO::IIOPServer::listen (CORBA::Address *addr, CORBA::Address *fwproxyaddr)
{
    CORBA::IORProfile *prof;
    CORBA::TransportServer *tserv = addr->make_transport_server ();
    if (!tserv->bind (addr)) {
      if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
        MICO::Logger::Stream (MICO::Logger::IIOP)
          << "IIOP: cannot bind to " << addr->stringify() << ": "
          << tserv->errormsg() << endl;
      }
      return 0;
    }
    tserv->block (MICO::IIOPProxy::isblocking());
    tserv->aselect (_orb->dispatcher(), this);

    if (!fwproxyaddr) {
        prof = tserv->addr()->make_ior_profile ((CORBA::Octet *)"", 1,
                                                CORBA::MultiComponent(),
                                                _iiop_ver);
    } else {
        prof = fwproxyaddr->make_ior_profile ((CORBA::Octet *)"", 1,
                                              CORBA::MultiComponent(),
                                              _iiop_ver);
    }


    if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
      MICO::Logger::Stream (MICO::Logger::IIOP)
        << "IIOP: server listening on "
        << tserv->addr()->stringify()
        << " IIOP version "
        << (_iiop_ver >> 8) << "." << (_iiop_ver & 255)
        << endl;
    }







    _orb->ior_template()->add_profile (prof);

    _tservers.push_back (tserv);
    return 1;
}

CORBA::Boolean
MICO::IIOPServer::listen ()
{
    InetAddress addr ("0.0.0.0", 0);
    return listen (&addr, 0);
}

MICO::IIOPServerInvokeRec *
MICO::IIOPServer::create_invoke ()
{
    if (!_cache_used) {
        _cache_used = 1;
        return _cache_rec;
    }

    return new IIOPServerInvokeRec;
}

MICO::IIOPServerInvokeRec *
MICO::IIOPServer::get_invoke_reqid (MsgId msgid, GIOPConn *conn)
{
    if (_cache_used && _cache_rec->reqid() == msgid &&
        _cache_rec->conn() == conn)
        return _cache_rec;



    IIOPServerInvokeRec *rec;
    for (MapIdConn::iterator i = _orbids.begin(); i != _orbids.end(); ++i) {
        rec = (*i).second;
        if (rec->reqid() == msgid && rec->conn() == conn)
            return rec;
    }
    return 0;
}

MICO::IIOPServerInvokeRec *
MICO::IIOPServer::get_invoke_orbid (MsgId msgid)
{
    if (_cache_used && _cache_rec->orbid() == msgid)
        return _cache_rec;

    MapIdConn::iterator i = _orbids.find (msgid);
    return (i != _orbids.end() ? (*i).second : 0);
}

void
MICO::IIOPServer::add_invoke (IIOPServerInvokeRec *rec)
{
    if (_cache_rec == rec)
        return;


    _orbids[rec->orbid()] = rec;
}

void
MICO::IIOPServer::del_invoke_orbid (MsgId msgid)
{
    if (_cache_used && _cache_rec->orbid() == msgid) {
        _cache_rec->free();
        _cache_used = 0;
        return;
    }

    MapIdConn::iterator i = _orbids.find (msgid);
    if (i != _orbids.end()) {
        delete (*i).second;
        _orbids.erase (i);
    }
}

void
MICO::IIOPServer::del_invoke_reqid (MsgId msgid, GIOPConn *conn)
{
    if (_cache_used && _cache_rec->reqid() == msgid &&
        _cache_rec->conn() == conn) {
        _cache_rec->free();
        _cache_used = 0;
        return;
    }


    IIOPServerInvokeRec *rec;
    for (MapIdConn::iterator i = _orbids.begin(); i != _orbids.end(); ++i) {
        rec = (*i).second;
        if (rec->reqid() == msgid && rec->conn() == conn) {
            delete rec;
            _orbids.erase (i);
            break;
        }
    }
}

void
MICO::IIOPServer::abort_invoke_orbid (MsgId msgid)
{
    _orb->cancel (msgid);
    del_invoke_orbid (msgid);
}

void
MICO::IIOPServer::kill_conn (GIOPConn *conn)
{
    CORBA::Boolean again;

    do {
        again = 0;
        for (ListConn::iterator i = _conns.begin(); i != _conns.end(); ++i) {
            if (*i == conn) {
                _conns.erase (i);
                again = 1;
                break;
            }
        }
    } while (again);



    if (_cache_used && _cache_rec->conn() == conn) {
        _orb->cancel (_cache_rec->orbid());
        _cache_used = 0;
    }

    do {
        again = 0;
        IIOPServerInvokeRec *rec;
        for (MapIdConn::iterator i = _orbids.begin(); i != _orbids.end(); ++i) {
            rec = (*i).second;
            if (rec->conn() == conn) {
                abort_invoke_orbid (rec->orbid());
                again = 1;
                break;
            }
        }
    } while (again);
    delete conn;
}

void
MICO::IIOPServer::conn_error (GIOPConn *conn, CORBA::Boolean send_error)
{
    if (!send_error) {
        kill_conn (conn);
        return;
    }

    GIOPOutContext out (conn->codec());
    conn->codec()->put_error_msg (out);
    conn->output (out._retn());
    conn->deref (1);
    conn->flush();
}

void
MICO::IIOPServer::conn_closed (GIOPConn *conn)
{
    GIOPOutContext out (conn->codec());
    conn->codec()->put_close_msg (out);
    conn->output (out._retn());
    conn->deref (1);
    conn->flush();
}

CORBA::Boolean
MICO::IIOPServer::handle_input (GIOPConn *conn)
{
    if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
      MICO::Logger::Stream (MICO::Logger::IIOP)
        << "IIOP: incoming data from "
        << conn->transport()->peer()->stringify() << endl;
    }

    GIOPInContext in (conn->codec(), conn->input());

    CORBA::GIOP::MsgType mt;
    CORBA::ULong size;
    CORBA::Octet flags;


    if (!conn->codec()->get_header (in, mt, size, flags)) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: cannot decode incoming header from "
          << conn->transport()->peer()->stringify() << endl;
      }
      conn_error (conn);
      return 0;
    }

    switch (mt) {
    case CORBA::GIOP::Request:
      return handle_invoke_request (conn, in);

    case CORBA::GIOP::LocateRequest:
      return handle_locate_request (conn, in);

    case CORBA::GIOP::MessageError:
        if (!conn->codec()->get_error_msg (in)) {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: cannot decode MessageError from "
              << conn->transport()->peer()->stringify() << endl;
          }
          conn_error (conn, 0);
        } else {
          if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
            MICO::Logger::Stream (MICO::Logger::GIOP)
              << "GIOP: incoming MessageError from "
              << conn->transport()->peer()->stringify() << endl;
          }
          kill_conn (conn);
        }
        return 0;

    case CORBA::GIOP::CancelRequest:
      return handle_cancel_request (conn, in);

    case CORBA::GIOP::CloseConnection:
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: incoming CloseConnection from "
          << conn->transport()->peer()->stringify() << endl;
      }


      break;

    default:
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: bad incoming message type (" << mt << ") from "
          << conn->transport()->peer()->stringify() << endl;
      }
      break;
    }
    return 1;
}

MICO::IIOPServer::MsgId
MICO::IIOPServer::exec_invoke_request (GIOPInContext &in,
                                       CORBA::Object_ptr obj,
                                       CORBA::ORBRequest *req,
                                       CORBA::Principal_ptr pr,
                                       CORBA::Boolean resp_exp,
                                       GIOPConn *conn,
                                       MsgId orbid)
{
    if (!strcmp (req->op_name(), "_bind")) {

        CORBA::String_var repoid;
        CORBA::ORB::ObjectTag oid;
        CORBA::Boolean r = conn->codec()->get_bind_request (in, repoid.out(),
                                                            oid);
        ((void) ((r) ? 0 : (__assert_fail ("r", "iop.cc", 3589, __PRETTY_FUNCTION__), 0)));




        return _orb->bind_async (repoid, oid, 0, this, orbid);
    } else {

        return _orb->invoke_async (obj, req, pr, resp_exp, this, orbid);
    }
}

CORBA::Boolean
MICO::IIOPServer::handle_invoke_request (GIOPConn *conn, GIOPInContext &in)
{
    CORBA::ULong req_id;
    CORBA::Boolean resp;
    CORBA::ORBRequest *req;
    CORBA::Principal_ptr pr = conn->transport()->get_principal();
    CORBA::Object_ptr obj = new CORBA::Object (new CORBA::IOR);


    if (!conn->codec()->get_invoke_request (in, req_id, resp, obj, req, pr)) {
        CORBA::release (obj);
        CORBA::release (pr);
        if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
          MICO::Logger::Stream (MICO::Logger::GIOP)
            << "GIOP: cannot decode Request from "
            << conn->transport()->peer()->stringify() << endl;
        }
        conn_error (conn);
        return 0;
    }


    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: incoming Request from "
        << conn->transport()->peer()->stringify()
        << " with msgid " << req_id << endl;
    }
# 3641 "iop.cc"
    MsgId orbid = _orb->new_msgid();
    if (resp) {
        conn->ref ();
        IIOPServerInvokeRec *rec = create_invoke();
        rec->init_invoke (conn, req_id, orbid, req, obj, pr);
        add_invoke (rec);
    }
    MsgId orbid2 = exec_invoke_request (in, obj, req, pr, resp, conn, orbid);
    ((void) ((orbid == orbid2 || (orbid2 == 0 && !resp)) ? 0 : (__assert_fail ("orbid == orbid2 || (orbid2 == 0 && !resp)", "iop.cc", 3649, __PRETTY_FUNCTION__), 0)));

    if (!resp) {
        CORBA::release (req);
        CORBA::release (obj);
        CORBA::release (pr);
    }


    return 0;
}

CORBA::Boolean
MICO::IIOPServer::handle_locate_request (GIOPConn *conn, GIOPInContext &in)
{
    CORBA::ULong req_id;
    CORBA::Object_ptr obj = new CORBA::Object (new CORBA::IOR);

    if (!conn->codec()->get_locate_request (in, req_id, obj)) {
        CORBA::release (obj);
        if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
          MICO::Logger::Stream (MICO::Logger::GIOP)
            << "GIOP: cannot decode LocateRequest from "
            << conn->transport()->peer()->stringify() << endl;
        }
        conn_error (conn);
        return 0;
    }


    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: incoming LocateRequest from "
        << conn->transport()->peer()->stringify()
        << " with msgid " << req_id << endl;
    }





    MsgId orbid = _orb->new_msgid();
    conn->ref ();
    IIOPServerInvokeRec *rec = create_invoke();
    rec->init_locate (conn, req_id, orbid, obj);
    add_invoke (rec);

    MsgId orbid2 = _orb->locate_async (obj, this, orbid);
    ((void) ((orbid == orbid2) ? 0 : (__assert_fail ("orbid == orbid2", "iop.cc", 3697, __PRETTY_FUNCTION__), 0)));


    return 0;
}

CORBA::Boolean
MICO::IIOPServer::handle_cancel_request (GIOPConn *conn, GIOPInContext &in)
{
    CORBA::ULong req_id;

    if (!conn->codec()->get_cancel_request (in, req_id)) {
      if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
        MICO::Logger::Stream (MICO::Logger::GIOP)
          << "GIOP: cannot decode CancelRequest from "
          << conn->transport()->peer()->stringify() << endl;
      }
      conn_error (conn);
      return 0;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: incoming CancelRequest from "
        << conn->transport()->peer()->stringify()
        << " for msgid " << req_id << endl;
    }

    conn->cancel (req_id);

    IIOPServerInvokeRec *rec = get_invoke_reqid (req_id, conn);
    if (!rec) {

        return 1;
    }
    MsgId orbid = rec->orbid();



    rec->conn()->deref ();
    del_invoke_orbid (orbid);

    _orb->cancel (orbid);


    return 0;
}

void
MICO::IIOPServer::handle_invoke_reply (MsgId msgid)
{
    CORBA::ORBRequest *req;
    CORBA::Object_ptr obj = CORBA::Object::_nil();
    CORBA::GIOP::AddressingDisposition ad;
    CORBA::InvokeStatus stat = _orb->get_invoke_reply (msgid, obj, req, ad);

    IIOPServerInvokeRec *rec = get_invoke_orbid (msgid);
    if (!rec) {

        CORBA::release (obj);
        return;
    }

    CORBA::GIOP::ReplyStatusType giop_stat = CORBA::GIOP::NO_EXCEPTION;
    switch (stat) {
    case CORBA::InvokeSysEx:
        giop_stat = CORBA::GIOP::SYSTEM_EXCEPTION;
        break;

    case CORBA::InvokeUsrEx:
        giop_stat = CORBA::GIOP::USER_EXCEPTION;
        break;

    case CORBA::InvokeOk:
        giop_stat = CORBA::GIOP::NO_EXCEPTION;
        break;

    case CORBA::InvokeForward:
        giop_stat = CORBA::GIOP::LOCATION_FORWARD;
        break;

    case CORBA::InvokeAddrDisp:
        giop_stat = CORBA::GIOP::NEEDS_ADDRESSING_MODE;
        break;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending Reply to "
        << rec->conn()->transport()->peer()->stringify()
        << " for msgid " << rec->reqid()
        << " status is " << (CORBA::ULong) giop_stat
        << endl;
    }

    GIOPOutContext out (rec->conn()->codec());
    if (!rec->conn()->codec()->put_invoke_reply (out, rec->reqid(), giop_stat,
                                                 obj, req, ad)) {
        out.reset ();
        CORBA::MARSHAL ex;
        req->set_out_args (&ex);
        rec->conn()->codec()->put_invoke_reply (out, rec->reqid(),
                                                CORBA::GIOP::SYSTEM_EXCEPTION,
                                                obj, req, ad);
    }
    CORBA::release (obj);

    rec->conn()->output (out._retn());
    rec->conn()->deref ();
    del_invoke_orbid (rec->orbid());
}

void
MICO::IIOPServer::handle_locate_reply (MsgId msgid)
{
    CORBA::Object_ptr obj = CORBA::Object::_nil();
    CORBA::GIOP::AddressingDisposition ad;
    CORBA::LocateStatus stat = _orb->get_locate_reply (msgid, obj, ad);

    IIOPServerInvokeRec *rec = get_invoke_orbid (msgid);
    if (!rec) {

        CORBA::release (obj);
        return;
    }

    CORBA::GIOP::LocateStatusType giop_stat = CORBA::GIOP::OBJECT_HERE;
    switch (stat) {
    case CORBA::LocateHere:
        giop_stat = CORBA::GIOP::OBJECT_HERE;
        break;

    case CORBA::LocateUnknown:
        giop_stat = CORBA::GIOP::UNKNOWN_OBJECT;
        break;

    case CORBA::LocateForward:
        giop_stat = CORBA::GIOP::OBJECT_FORWARD;
        break;

    case CORBA::LocateAddrDisp:
        giop_stat = CORBA::GIOP::LOC_NEEDS_ADDRESSING_MODE;
        break;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending LocateReply to "
        << rec->conn()->transport()->peer()->stringify()
        << " for msgid " << rec->reqid()
        << " status is " << (CORBA::ULong) giop_stat
        << endl;
    }

    GIOPOutContext out (rec->conn()->codec());
    rec->conn()->codec()->put_locate_reply (out, rec->reqid(),
                                            giop_stat, obj, ad);
    CORBA::release (obj);

    rec->conn()->output (out._retn());
    rec->conn()->deref ();
    del_invoke_orbid (rec->orbid());
}

void
MICO::IIOPServer::handle_bind_reply (MsgId msgid)
{
    CORBA::Object_ptr obj = CORBA::Object::_nil();
    CORBA::LocateStatus stat = _orb->get_bind_reply (msgid, obj);

    IIOPServerInvokeRec *rec = get_invoke_orbid (msgid);
    if (!rec) {

        CORBA::release (obj);
        return;
    }

    CORBA::GIOP::LocateStatusType giop_stat = CORBA::GIOP::OBJECT_HERE;
    switch (stat) {
    case CORBA::LocateHere:
        giop_stat = CORBA::GIOP::OBJECT_HERE;
        break;

    case CORBA::LocateUnknown:
        giop_stat = CORBA::GIOP::UNKNOWN_OBJECT;
        break;

    case CORBA::LocateForward:
        giop_stat = CORBA::GIOP::OBJECT_FORWARD;
        break;
    }

    if (MICO::Logger::IsLogged (MICO::Logger::GIOP)) {
      MICO::Logger::Stream (MICO::Logger::GIOP)
        << "GIOP: sending _bind Reply to "
        << rec->conn()->transport()->peer()->stringify()
        << " for msgid " << rec->reqid()
        << " status is " << (CORBA::ULong) giop_stat
        << endl;
    }

    GIOPOutContext out (rec->conn()->codec());
    rec->conn()->codec()->put_bind_reply (out, rec->reqid(), giop_stat, obj);
    CORBA::release (obj);

    rec->conn()->output (out._retn());
    rec->conn()->deref ();
    del_invoke_orbid (rec->orbid());
}

const char *
MICO::IIOPServer::get_oaid () const
{
    return "mico-iiop-server";
}

CORBA::Boolean
MICO::IIOPServer::has_object (CORBA::Object_ptr)
{
    return 0;
}

CORBA::Boolean
MICO::IIOPServer::is_local () const
{


    return 0;
}

CORBA::Boolean
MICO::IIOPServer::invoke (MsgId, CORBA::Object_ptr,
                          CORBA::ORBRequest *,
                          CORBA::Principal_ptr, CORBA::Boolean)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3932, __PRETTY_FUNCTION__), 0)));
    return 1;
}

CORBA::Boolean
MICO::IIOPServer::bind (MsgId, const char *,
                        const CORBA::ORB::ObjectTag &,
                        CORBA::Address *)
{
    return 0;
}

CORBA::Boolean
MICO::IIOPServer::locate (MsgId, CORBA::Object_ptr)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3947, __PRETTY_FUNCTION__), 0)));
    return 0;
}

CORBA::Object_ptr
MICO::IIOPServer::skeleton (CORBA::Object_ptr)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3954, __PRETTY_FUNCTION__), 0)));
    return CORBA::Object::_nil ();
}

void
MICO::IIOPServer::cancel (MsgId)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3961, __PRETTY_FUNCTION__), 0)));
}

void
MICO::IIOPServer::shutdown (CORBA::Boolean wait_for_completion)
{
    for (mico_vec_size_type i2 = 0; i2 < _tservers.size(); ++i2) {
        _tservers[i2]->aselect (_orb->dispatcher(), 0);
        delete _tservers[i2];
    }
    _tservers.erase (_tservers.begin(), _tservers.end());





    for (ListConn::iterator i0 = _conns.begin(); i0 != _conns.end(); ++i0) {
        conn_closed (*i0);
        delete *i0;
    }
    _conns.erase (_conns.begin(), _conns.end());

    if (_cache_used)
        _orb->cancel (_cache_rec->orbid());
    for (MapIdConn::iterator i1 = _orbids.begin(); i1 != _orbids.end(); ++i1) {
        _orb->cancel ((*i1).first);
        delete (*i1).second;
    }
    _orbids.erase (_orbids.begin(), _orbids.end());
    _cache_used = 0;

    _orb->answer_shutdown (this);
}

void
MICO::IIOPServer::answer_invoke (CORBA::ULong, CORBA::Object_ptr,
                                 CORBA::ORBRequest *, CORBA::InvokeStatus)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 3999, __PRETTY_FUNCTION__), 0)));
}

void
MICO::IIOPServer::callback (CORBA::ORB_ptr, MsgId msgid,
                            CORBA::ORBCallback::Event ev)
{
    switch (ev) {
    case CORBA::ORBCallback::Invoke:
        handle_invoke_reply (msgid);
        break;

    case CORBA::ORBCallback::Locate:
        handle_locate_reply (msgid);
        break;

    case CORBA::ORBCallback::Bind:
        handle_bind_reply (msgid);
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 4020, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::IIOPServer::callback (GIOPConn *conn, GIOPConnCallback::Event ev)
{
    switch (ev) {
    case GIOPConnCallback::InputReady:
        return handle_input (conn);

    case GIOPConnCallback::Idle:
        if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
          MICO::Logger::Stream (MICO::Logger::IIOP)
            << "IIOP: shutting down idle conn to "
            << conn->transport()->peer()->stringify() << endl;
        }
        conn_closed (conn);
        kill_conn (conn);
        return 0;

    case GIOPConnCallback::Closed: {
        if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
          MICO::Logger::Stream (MICO::Logger::IIOP)
            << "IIOP: connection to "
            << conn->transport()->peer()->stringify()
            << " closed or broken" << endl;
        }
        const CORBA::Address *addr = conn->transport()->peer();
        ((void) ((addr) ? 0 : (__assert_fail ("addr", "iop.cc", 4049, __PRETTY_FUNCTION__), 0)));
        Interceptor::ConnInterceptor::
            _exec_client_disconnect (addr->stringify().c_str());
        kill_conn (conn);
        return 0;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 4056, __PRETTY_FUNCTION__), 0)));
    }
    return 1;
}

void
MICO::IIOPServer::callback (CORBA::TransportServer *tserv,
                            CORBA::TransportServerCallback::Event ev)
{
    switch (ev) {
    case CORBA::TransportServerCallback::Accept: {
        CORBA::Transport *t = tserv->accept();
        if (t) {
            if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
              MICO::Logger::Stream (MICO::Logger::IIOP)
                << "IIOP: new connection opened from "
                << t->peer()->stringify() << endl;
            }
            if (t->bad()) {
                if (MICO::Logger::IsLogged (MICO::Logger::IIOP)) {
                  MICO::Logger::Stream (MICO::Logger::IIOP)
                    << "IIOP: connection from "
                    << t->peer()->stringify()
                    << " is bad: " << t->errormsg() << endl;
                }
                delete t;
                break;
            }
            const CORBA::Address *addr = t->peer();
            ((void) ((addr) ? 0 : (__assert_fail ("addr", "iop.cc", 4085, __PRETTY_FUNCTION__), 0)));
            CORBA::Boolean r = Interceptor::ConnInterceptor::
                _exec_client_connect (addr->stringify().c_str());
            if (!r) {
                delete t;
                break;
            }
            GIOPConn *conn =
                new GIOPConn (_orb, t, this,
                              new GIOPCodec (new CDRDecoder,
                                             new CDREncoder,
                                             _iiop_ver),
                              0L );
            _conns.push_back (conn);
        }
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "iop.cc", 4103, __PRETTY_FUNCTION__), 0)));
    }
}
# 12 "orb_all.cc" 2
# 1 "ior.cc" 1
# 25 "ior.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "ior.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "ior.cc" 2

# 1 "/usr/include/ctype.h" 1 3 4
# 30 "ior.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "ior.cc" 2
# 1 "../include/mico/impl.h" 1
# 32 "ior.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "ior.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "ior.cc" 2
# 1 "../include/mico/ssl.h" 1
# 35 "ior.cc" 2
# 1 "../include/mico/os-misc.h" 1
# 36 "ior.cc" 2





CORBA::IORProfile::~IORProfile ()
{
}

CORBA::MultiComponent *
CORBA::IORProfile::components ()
{
    return 0;
}


CORBA::IORProfileDecoder::~IORProfileDecoder ()
{
}






CORBA::IOR::IOR (const char *objid, const IORProfileVec &t)
    : oid (objid)
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;
    for (mico_vec_size_type i = 0; i < t.size(); ++i)
        add_profile (t[i]);
}

CORBA::IOR::IOR (DataDecoder &dc)
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;
    CORBA::Boolean r = dc.get_ior (*this);
    ((void) ((r) ? 0 : (__assert_fail ("r", "ior.cc", 77, __PRETTY_FUNCTION__), 0)));
}

CORBA::IOR::IOR (const char *_ior)
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;
    CORBA::Boolean r = from_string (_ior);
    ((void) ((r) ? 0 : (__assert_fail ("r", "ior.cc", 86, __PRETTY_FUNCTION__), 0)));
}

CORBA::IOR::IOR (const IOR &ior)
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;
    copy (ior);
}

CORBA::IOR::IOR ()
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;
}

CORBA::IOR::~IOR ()
{
    free ();
}

CORBA::IOR &
CORBA::IOR::operator= (const IOR &ior)
{
    if (this != &ior) {
      _active_profile_index = 0;
      _addressing_disposition = 0;
        free ();
        copy (ior);
    }
    return *this;
}

CORBA::Boolean
CORBA::IOR::from_string (const char *_ior)
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;

    string ior (_ior);
    if (ior.find ("IOR:") != 0)
        return 0;

    ULong len = ior.length();
    if (((len-4) & 1) != 0)
        return 0;

    Buffer b;
    for (ULong i = 4; i < len; i += 2) {
        if (!isxdigit (ior[i]) || !isxdigit (ior[i+1]))
            return 0;
        b.put ((mico_from_xdigit (ior[i]) << 4) | mico_from_xdigit (ior[i+1]));
    }




    MICO::CDRDecoder dc (&b, 0);






    Octet bo;
    if (!dc.get_octet (bo))
        return 0;
    dc.byteorder (bo ? CORBA::LittleEndian : CORBA::BigEndian);
    if (!decode (dc)) {
        free ();
        return 0;
    }
    return 1;
}

CORBA::Long
CORBA::IOR::compare (const IOR &ior) const
{





    int len = tags.size() < ior.tags.size() ? tags.size() : ior.tags.size();
    CORBA::Long r;
    for (int i = 0; i < len; ++i) {
        r = tags[i]->compare (*ior.tags[i]);
        if (r)
            return r;
    }
    return tags.size() - ior.tags.size();
}

CORBA::Long
CORBA::IOR::compare_reachable (const IOR &ior) const
{





    int ilen = tags.size();
    int jlen = ior.tags.size();
    CORBA::Long r;
    for (int i = 0, j = 0;; ++i, ++j) {
        while (i < ilen && !tags[i]->reachable())
            ++i;
        while (j < jlen && !ior.tags[j]->reachable())
            ++j;
        if (i == ilen)
            return j-jlen;
        if (j == jlen)
            return 1;
        r = tags[i]->compare (*ior.tags[j]);
        if (r)
            return r;
    }
}

CORBA::Boolean
CORBA::IOR::operator== (const IOR &ior) const
{
    return compare (ior) == 0;
}

CORBA::Boolean
CORBA::IOR::operator< (const IOR &ior) const
{
    return compare (ior) < 0;
}

void
CORBA::IOR::free ()
{
  _active_profile = 0;
  _active_profile_index = 0;
  _addressing_disposition = 0;

    for (ULong i = 0; i < tags.size(); ++i)
        delete tags[i];
    tags.erase (tags.begin(), tags.end());
}

void
CORBA::IOR::copy (const IOR &ior)
{
    tags.erase (tags.begin(), tags.end());
    for (ULong i = 0; i < ior.tags.size(); ++i)
        add_profile (ior.tags[i]->clone());
    oid = ior.oid;
}



CORBA::Boolean
CORBA::IOR::decode (DataDecoder &dc)
{
    {
        free ();

        ULong len;

        if (!(dc.struct_begin ())) goto bad;
        if (!(dc.get_string_raw_stl (oid))) goto bad;
        if (!(dc.seq_begin (len))) goto bad;

        IORProfile *tag;
        for (ULong i = 0; i < len; ++i) {
            tag = IORProfile::decode (dc);
            if (!(tag)) goto bad;
            add_profile (tag);
        }
        if (!(dc.seq_end ())) goto bad;
        if (!(dc.struct_end ())) goto bad;
        return 1;
    }

bad:
    free ();
    return 0;
}



const CORBA::Address *
CORBA::IOR::addr (IORProfile::ProfileId id, Boolean find_unreach,
                  const Address *prev) const
{
    mico_vec_size_type i = 0;
    if (prev) {
        for ( ; i < tags.size(); ++i) {
            if (tags[i]->addr() == prev) {
                ++i;
                break;
            }
        }
    }
    for ( ; i < tags.size(); ++i) {
        if (id == IORProfile::TAG_ANY || tags[i]->id() == id) {
            if (find_unreach || tags[i]->reachable())
                return tags[i]->addr();
        }
    }
    return 0;
}

CORBA::IORProfile *
CORBA::IOR::profile (IORProfile::ProfileId id, Boolean find_unreach,
                     IORProfile *prev)
{
    mico_vec_size_type i = 0;
    if (prev) {
        for ( ; i < tags.size(); ++i) {
            if (tags[i] == prev) {
                ++i;
                break;
            }
        }
    }
    for ( ; i < tags.size(); ++i) {
        if (id == IORProfile::TAG_ANY || tags[i]->id() == id) {
            if (find_unreach || tags[i]->reachable())
                return tags[i];
        }
    }
    return 0;
}

CORBA::IORProfile *
CORBA::IOR::active_profile (CORBA::ULong * index)
{
  if (_active_profile && index) {
    *index = _active_profile_index;
  }
  return _active_profile;
}

void
CORBA::IOR::active_profile (CORBA::IORProfile * prof)
{
  CORBA::ULong i;

  if (!prof) {
    _active_profile = prof;
    return;
  }

  for (i=0; i<tags.size(); i++) {
    if (tags[i] == prof) {
      _active_profile_index = i;
      break;
    }
  }

  ((void) ((i != tags.size()) ? 0 : (__assert_fail ("i != tags.size()", "ior.cc", 343, __PRETTY_FUNCTION__), 0)));
  _active_profile = prof;
}

CORBA::GIOP::AddressingDisposition
CORBA::IOR::addressing_disposition ()
{
  return _addressing_disposition;
}

void
CORBA::IOR::addressing_disposition (CORBA::GIOP::AddressingDisposition disp)
{
  _addressing_disposition = disp;
}

void
CORBA::IOR::add_profile (IORProfile *prof)
{
    int i = tags.size();
    while (--i >= 0 && *prof < *tags[i])
        ;
    tags.insert (tags.begin()+i+1, prof);
}

void
CORBA::IOR::del_profile (IORProfile *prof)
{
    for (mico_vec_size_type i = 0; i < tags.size(); ++i) {
        if (tags[i] == prof) {
            tags.erase (tags.begin()+i);
            break;
        }
    }
    if (prof == _active_profile) {
      _active_profile = 0;
    }
}

CORBA::IORProfile *
CORBA::IOR::get_profile (ULong i)
{
  if (i >= tags.size()) return 0;
  return tags[i];
}

const char *
CORBA::IOR::objid () const
{
    return oid.c_str();
}

void
CORBA::IOR::objid (const char *s)
{
    oid = s;
}

void
CORBA::IOR::objectkey (Octet *key, ULong keylen)
{
    for (mico_vec_size_type i = 0; i < tags.size(); ++i) {
        tags[i]->objectkey (key, keylen);
    }
}

void
CORBA::IOR::encode (DataEncoder &ec) const
{
    CORBA::DataEncoder::EncapsState state;

    ec.struct_begin ();
    ec.put_string_raw (oid.c_str());
    ec.seq_begin (tags.size());
    for (ULong i = 0; i < tags.size(); ++i) {
        ec.struct_begin ();
        ec.put_ulong (tags[i]->encode_id());

        ec.encaps_begin (state);
        tags[i]->encode (ec);
        ec.encaps_end (state);
        ec.struct_end ();
    }
    ec.seq_end ();
    ec.struct_end ();
}

string
CORBA::IOR::stringify () const
{
    string s ("IOR:");

    MICO::CDREncoder ec;





    ec.put_octet (ec.byteorder() == CORBA::BigEndian ? 0 : 1);
    encode (ec);

    Buffer *b = ec.buffer();
    Octet o;
    for (Long i = b->length(); --i >= 0; ) {
        b->get (o);
        s += mico_to_xdigit ((o >> 4) & 0xf);
        s += mico_to_xdigit (o & 0xf);
    }
    return s;
}

void
CORBA::IOR::print (ostream &o) const
{
    CORBA::Long len, j, k;
    char buf[10];

    o << "    Repo Id:  ";
    if (oid.length()) {
      o << oid << endl << endl;
    }
    else {
      o << "(unknown)" << endl << endl;
    }

    for (mico_vec_size_type i = 0; i < tags.size(); ++i) {
      tags[i]->print (o);

      const CORBA::Octet *key = tags[i]->objectkey (len);
      if (key) {
        o << "        Key:  ";
        for (j=0; j<len; j+=16) {
          for (k=j; k<j+16 && k<len; k++) {
            sprintf (buf, "%02x ", (int) key[k]);
            o << buf;
          }
          for (; k<j+16; k++) {
            sprintf (buf, "   ");
            o << buf;
          }
          for (k=j; k<j+16 && k<len; k++) {
            if (isprint (key[k])) {
              o << (char) key[k];
            }
            else {
              o << '.';
            }
          }
          o << endl;

          if (k < len) {
            o << "              ";
          }
        }
        if (len == 0) {
          o << "(empty)";
        }
        if (j == len) {
          o << endl;
        }
      }
      o << endl;
    }
}






namespace CORBA {
  vector<CORBA::IORProfileDecoder *> *IORProfile::decoders = 0;
};




void
CORBA::IORProfile::copy (IORProfile *p)
{
}



CORBA::IORProfile *
CORBA::IORProfile::decode (DataDecoder &dc)
{
    ULong pid, len, next_pos;
    CORBA::DataDecoder::EncapsState state;
    IORProfile *p = 0;

    if (!(dc.struct_begin ())) goto bad;
    if (!(dc.get_ulong (pid))) goto bad;
    if (!(dc.encaps_begin (state, len))) goto bad;

    next_pos = dc.buffer()->rpos() + len;
    p = decode_body (dc, (ProfileId)pid, len);

    if (!(dc.buffer()->rseek_beg (next_pos))) goto bad;

    if (!(p)) goto bad;
    if (!(dc.encaps_end (state))) goto bad;
    if (!(dc.struct_end ())) goto bad;
    return p;

bad:
    if (p)
        delete p;
    return 0;
}



CORBA::IORProfile *
CORBA::IORProfile::decode_body (DataDecoder &dc, ProfileId pid, ULong len)
{
    if (!decoders)
        decoders = new vector<CORBA::IORProfileDecoder *>;

    ULong i;
    IORProfile *p;

    for (i = 0; i < decoders->size(); ++i) {
        if ((*decoders)[i]->has_id (pid))
            break;
    }
    if (i < decoders->size()) {

        p = (*decoders)[i]->decode (dc, pid, len);
    } else {

        p = MICO::UnknownProfile::decode (dc, pid, len);
    }
    return p;
}

void
CORBA::IORProfile::register_decoder (IORProfileDecoder *decoder)
{
    if (!decoders)
        decoders = new vector<CORBA::IORProfileDecoder *>;
    decoders->push_back (decoder);
}

void
CORBA::IORProfile::unregister_decoder (IORProfileDecoder *decoder)
{
    if (!decoders)
        return;
    for (ULong i = 0; i < decoders->size(); ) {
        if ((*decoders)[i] == decoder)
            decoders->erase (decoders->begin() + i);
        else
            ++i;
    }
}





MICO::LocalProfile::LocalProfile (CORBA::Octet *o, CORBA::ULong l,
                                  ProfileId id,
                                  const char *_host,
                                  CORBA::Long _pid)
{
    tagid = id;
    host = _host ? _host : InetAddress::hostname().c_str();
    pid = (_pid >= 0) ? _pid : OSMisc::getpid();
    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);
}

MICO::LocalProfile::LocalProfile (const LocalProfile &lp)
{
    tagid = lp.tagid;
    host = lp.host;
    pid = lp.pid;
    objkey = new CORBA::Octet[length = lp.length];
    memcpy (objkey, lp.objkey, length);
}

MICO::LocalProfile::~LocalProfile ()
{
    delete[] objkey;
}

MICO::LocalProfile &
MICO::LocalProfile::operator= (const LocalProfile &lp)
{
    if (this != &lp) {
        tagid = lp.tagid;
        host = lp.host;
        pid = lp.pid;
        objectkey (lp.objkey, lp.length);
    }
    return *this;
}

void
MICO::LocalProfile::encode (CORBA::DataEncoder &ec) const
{
    ec.struct_begin ();
    {
        ec.put_string_raw (host.c_str());
        ec.put_long (pid);

        ec.seq_begin (length);
        {
            ec.put_octets (objkey, length);
        }
        ec.seq_end ();
    }
    ec.struct_end ();
}

const CORBA::Address *
MICO::LocalProfile::addr () const
{
    return &myaddr;
}

CORBA::IORProfile::ProfileId
MICO::LocalProfile::id () const
{
    return tagid;
}

CORBA::IORProfile::ProfileId
MICO::LocalProfile::encode_id () const
{
    return tagid;
}

void
MICO::LocalProfile::objectkey (CORBA::Octet *o, CORBA::Long l)
{
    delete[] objkey;
    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);
}

const CORBA::Octet *
MICO::LocalProfile::objectkey (CORBA::Long &l) const
{
    l = length;
    return objkey;
}

CORBA::Boolean
MICO::LocalProfile::reachable ()
{




    return InetAddress::samehosts (host, InetAddress::hostname()) &&
        pid == OSMisc::getpid();

}

void
MICO::LocalProfile::print (ostream &o) const
{
  o << "Local Profile" << endl;
}

CORBA::IORProfile *
MICO::LocalProfile::clone () const
{
    return new LocalProfile (*this);
}

CORBA::Long
MICO::LocalProfile::compare (const CORBA::IORProfile &p) const
{
    if (p.id() != id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();
    const LocalProfile &lp = (const LocalProfile &)p;
    if (pid != lp.pid)
        return (CORBA::Long)pid - (CORBA::Long)lp.pid;
    if (length != lp.length)
        return (CORBA::Long)length - (CORBA::Long)lp.length;
    CORBA::Long r = mico_key_compare (objkey, lp.objkey, length);
    if (r)
        return r;
    r = host.compare (lp.host);
    if (r)
        return r;
    return myaddr.compare (lp.myaddr);
}

CORBA::Boolean
MICO::LocalProfile::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::LocalProfile::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}





MICO::LocalProfileDecoder::LocalProfileDecoder (
    CORBA::IORProfile::ProfileId id)
{
    tagid = id;
    CORBA::IORProfile::register_decoder (this);
}

MICO::LocalProfileDecoder::~LocalProfileDecoder ()
{
    CORBA::IORProfile::unregister_decoder (this);
}



CORBA::IORProfile *
MICO::LocalProfileDecoder::decode (CORBA::DataDecoder &dc, ProfileId,
                                   CORBA::ULong) const
{
    CORBA::ULong len;
    string host;
    CORBA::Long pid;
    LocalProfile *p = 0;

    if (!(dc.struct_begin ())) goto bad;
    {
        if (!(dc.get_string_raw_stl (host))) goto bad;
        if (!(dc.get_long (pid))) goto bad;

        if (!(dc.seq_begin (len))) goto bad;
        {
            if (!(dc.buffer()->length() >= len)) goto bad;
            p = new LocalProfile (dc.buffer()->data(), len,
                                  tagid, host.c_str(), pid);
            dc.buffer()->rseek_rel (len);
        }
        if (!(dc.seq_end ())) goto bad;
    }
    if (!(dc.struct_end ())) goto bad;
    return p;

bad:
    if (p)
        delete p;
    return 0;
}



CORBA::Boolean
MICO::LocalProfileDecoder::has_id (CORBA::IORProfile::ProfileId id) const
{
    return tagid == id;
}




static MICO::LocalProfileDecoder local_ior_decoder;






MICO::IIOPProfile::IIOPProfile (CORBA::Octet *o, CORBA::ULong l,
                                const InetAddress &ia,
                                const CORBA::MultiComponent &mc,
                                CORBA::UShort ver,
                                ProfileId id)
{
    version = ver;

    if (version < 0x0101 && mc.size() > 0)
        version = 0x0101;

    tagid = id;
    comps = mc;

    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);

    myaddr = ia;
}

MICO::IIOPProfile::IIOPProfile (const IIOPProfile &ip)
{
    version = ip.version;

    tagid = ip.tagid;
    myaddr = ip.myaddr;
    comps = ip.comps;
    objkey = new CORBA::Octet[length = ip.length];
    memcpy (objkey, ip.objkey, length);
}

MICO::IIOPProfile::~IIOPProfile ()
{
    delete[] objkey;
}

MICO::IIOPProfile &
MICO::IIOPProfile::operator= (const IIOPProfile &ip)
{
    if (this != &ip) {
        version = ip.version;
        tagid = ip.tagid;
        myaddr = ip.myaddr;
        comps = ip.comps;
        objectkey (ip.objkey, ip.length);
    }
    return *this;
}

void
MICO::IIOPProfile::encode (CORBA::DataEncoder &ec) const
{
    ec.struct_begin ();
    {
        ec.struct_begin ();
        {
            ec.put_octet ((CORBA::Octet)(version >> 8));
            ec.put_octet ((CORBA::Octet)version);
        }
        ec.struct_end ();

        ec.put_string_raw (myaddr.host());
        ec.put_ushort (myaddr.port());

        ec.seq_begin (length);
        {
            ec.put_octets (objkey, length);
        }
        ec.seq_end ();

        if (version >= 0x0101)
            comps.encode (ec);
    }
    ec.struct_end ();
}

const CORBA::Address *
MICO::IIOPProfile::addr () const
{
    return &myaddr;
}

MICO::IIOPProfile::ProfileId
MICO::IIOPProfile::id () const
{
    return tagid;
}

MICO::IIOPProfile::ProfileId
MICO::IIOPProfile::encode_id () const
{
    return tagid;
}

void
MICO::IIOPProfile::objectkey (CORBA::Octet *o, CORBA::Long l)
{
    delete[] objkey;
    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);
}

const CORBA::Octet *
MICO::IIOPProfile::objectkey (CORBA::Long &l) const
{
    l = length;
    return objkey;
}

CORBA::Boolean
MICO::IIOPProfile::reachable ()
{
    return 1;
}

void
MICO::IIOPProfile::print (ostream &o) const
{
  o << "IIOP Profile" << endl;
  o << "    Version:  " << (CORBA::Long) (version >> 8) << "."
    << (CORBA::Long) (version & 0xff) << endl;
  o << "    Address:  " << myaddr.stringify() << endl;

  o << "   Location:  corbaloc::";
  if (version != 0x0100) {
    o << (CORBA::Long) (version >> 8) << "."
      << (CORBA::Long) (version & 0xff) << "@";
  }
  o << myaddr.host() << ":" << myaddr.port();
  if (length > 0) {
    CORBA::String_var url = mico_url_encode (objkey, length);
    o << "/" << url.in() << endl;
  }

  comps.print (o);
}

CORBA::IORProfile *
MICO::IIOPProfile::clone () const
{
    return new IIOPProfile (*this);
}

CORBA::Long
MICO::IIOPProfile::compare (const CORBA::IORProfile &p) const
{
    if (p.id() != id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();

    const IIOPProfile &ip = (const IIOPProfile &)p;

    if (length != ip.length)
        return (CORBA::Long)length - (CORBA::Long)ip.length;

    CORBA::Long r = mico_key_compare (objkey, ip.objkey, length);
    if (r)
        return r;

    if (version != ip.version)
        return (CORBA::Long)version - (CORBA::Long)ip.version;

    r = myaddr.compare (ip.myaddr);
    if (r)
        return r;

    return comps.compare (ip.comps);
}

CORBA::Boolean
MICO::IIOPProfile::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::IIOPProfile::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}





MICO::IIOPProfileDecoder::IIOPProfileDecoder (CORBA::IORProfile::ProfileId id,
                                              MICO::InetAddress::Family f)
{
    tagid = id;
    family = f;
    CORBA::IORProfile::register_decoder (this);
}

MICO::IIOPProfileDecoder::~IIOPProfileDecoder ()
{
    CORBA::IORProfile::unregister_decoder (this);
}



CORBA::IORProfile *
MICO::IIOPProfileDecoder::decode (CORBA::DataDecoder &dc, ProfileId,
                                  CORBA::ULong) const
{
    CORBA::Octet major, minor, *objkey;
    CORBA::UShort version;
    CORBA::ULong len;
    CORBA::UShort port;
    CORBA::MultiComponent comps;
    string host;
    CORBA::IORProfile *ip = 0;

    if (!(dc.struct_begin ())) goto bad;;
    {
        if (!(dc.struct_begin ())) goto bad;;
        {
            if (!(dc.get_octet (major))) goto bad;;
            if (!(dc.get_octet (minor))) goto bad;;
            version = ((major << 8) | minor);
        }
        if (!(dc.struct_end ())) goto bad;;

        if (!(dc.get_string_raw_stl (host))) goto bad;;
        if (!(dc.get_ushort (port))) goto bad;;

        if (!(dc.seq_begin (len))) goto bad;;
        {

            if (!(dc.buffer()->length() >= len)) goto bad;;
            objkey = dc.buffer()->data();
            dc.buffer()->rseek_rel (len);
        }
        if (!(dc.seq_end ())) goto bad;;

        if (major > 1 || minor > 0)
            if (!(comps.decode (dc))) goto bad;;

        ip = new IIOPProfile (objkey, len,
                              InetAddress (host.c_str(), port, family),
                              comps,
                              version,
                              tagid);






    }
    if (!(dc.struct_end ())) goto bad;;
    return ip;

bad:
    if (ip)
        delete ip;
    return 0;
}



CORBA::Boolean
MICO::IIOPProfileDecoder::has_id (MICO::IIOPProfile::ProfileId id) const
{
    return tagid == id;
}

static MICO::IIOPProfileDecoder iiop_ior_decoder (
    CORBA::IORProfile::TAG_INTERNET_IOP, MICO::InetAddress::STREAM);
static MICO::IIOPProfileDecoder udpiop_ior_decoder (
    CORBA::IORProfile::TAG_UDP_IOP, MICO::InetAddress::DGRAM);




MICO::UIOPProfile::UIOPProfile (CORBA::Octet *o, CORBA::ULong l,
                                const UnixAddress &ua,
                                const CORBA::MultiComponent &mc,
                                CORBA::UShort ver,
                                ProfileId id,
                                const char *_host)
{
    version = ver;

    if (version < 0x0101 && mc.size() > 0)
        version = 0x0101;

    tagid = id;
    if (_host)
        host = _host;
    else
        host = InetAddress::hostname();
    myaddr = ua;
    comps = mc;
    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);
}

MICO::UIOPProfile::UIOPProfile (const UIOPProfile &ip)
{
    version = ip.version;
    comps = ip.comps;
    tagid = ip.tagid;
    host = ip.host;
    myaddr = ip.myaddr;
    objkey = new CORBA::Octet[length = ip.length];
    memcpy (objkey, ip.objkey, length);
}

MICO::UIOPProfile::~UIOPProfile ()
{
    delete[] objkey;
}

MICO::UIOPProfile &
MICO::UIOPProfile::operator= (const UIOPProfile &ip)
{
    if (this != &ip) {
        version = ip.version;
        comps = ip.comps;
        tagid = ip.tagid;
        host = ip.host;
        myaddr = ip.myaddr;
        objectkey (ip.objkey, ip.length);
    }
    return *this;
}

void
MICO::UIOPProfile::encode (CORBA::DataEncoder &ec) const
{
    ec.struct_begin ();
    {
        ec.struct_begin ();
        {
            ec.put_octet ((CORBA::Octet)(version >> 8));
            ec.put_octet ((CORBA::Octet)version);
        }
        ec.struct_end ();

        ec.put_string_raw (host.c_str());
        ec.put_string_raw (myaddr.filename());

        ec.seq_begin (length);
        {
            ec.put_octets (objkey, length);
        }
        ec.seq_end ();

        if (version >= 0x0101)
            comps.encode (ec);
    }
    ec.struct_end ();
}

const CORBA::Address *
MICO::UIOPProfile::addr () const
{
    return &myaddr;
}

MICO::UIOPProfile::ProfileId
MICO::UIOPProfile::id () const
{
    return tagid;
}

MICO::UIOPProfile::ProfileId
MICO::UIOPProfile::encode_id () const
{
    return tagid;
}

void
MICO::UIOPProfile::objectkey (CORBA::Octet *o, CORBA::Long l)
{
    delete[] objkey;
    objkey = new CORBA::Octet[length = l];
    memcpy (objkey, o, length);
}

const CORBA::Octet *
MICO::UIOPProfile::objectkey (CORBA::Long &l) const
{
    l = length;
    return objkey;
}

CORBA::Boolean
MICO::UIOPProfile::reachable ()
{
    return InetAddress::samehosts (host, InetAddress::hostname());
}

void
MICO::UIOPProfile::print (ostream &o) const
{
  o << "UIOP Profile" << endl;
  o << "    Address:  " << myaddr.stringify() << endl;
}

CORBA::IORProfile *
MICO::UIOPProfile::clone () const
{
    return new UIOPProfile (*this);
}

CORBA::Long
MICO::UIOPProfile::compare (const CORBA::IORProfile &p) const
{
    if (p.id() != id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();

    const UIOPProfile &ip = (const UIOPProfile &)p;

    if (length != ip.length)
        return (CORBA::Long)length - (CORBA::Long)ip.length;

    CORBA::Long r = mico_key_compare (objkey, ip.objkey, length);
    if (r)
        return r;

    if (version != ip.version)
        return (CORBA::Long)version - (CORBA::Long)ip.version;

    r = host.compare (ip.host);
    if (r)
        return r;

    r = myaddr.compare (ip.myaddr);
    if (r)
        return r;

    return comps.compare (ip.comps);
}

CORBA::Boolean
MICO::UIOPProfile::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::UIOPProfile::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}





MICO::UIOPProfileDecoder::UIOPProfileDecoder (CORBA::IORProfile::ProfileId id)
{
    tagid = id;
    CORBA::IORProfile::register_decoder (this);
}

MICO::UIOPProfileDecoder::~UIOPProfileDecoder ()
{
    CORBA::IORProfile::unregister_decoder (this);
}



CORBA::IORProfile *
MICO::UIOPProfileDecoder::decode (CORBA::DataDecoder &dc, ProfileId,
                                  CORBA::ULong) const
{
    CORBA::Octet minor, major, *objkey;
    CORBA::UShort version;
    CORBA::ULong len;
    CORBA::MultiComponent comps;
    string host, filename;
    CORBA::IORProfile *ip = 0;

    if (!(dc.struct_begin ())) goto bad;
    {
        if (!(dc.struct_begin ())) goto bad;
        {
            if (!(dc.get_octet (major))) goto bad;
            if (!(dc.get_octet (minor))) goto bad;
            version = ((major << 8) | minor);
            if (!(version <= 0x0102)) goto bad;
        }
        if (!(dc.struct_end ())) goto bad;

        if (!(dc.get_string_raw_stl (host))) goto bad;
        if (!(dc.get_string_raw_stl (filename))) goto bad;

        if (!(dc.seq_begin (len))) goto bad;
        {

            if (!(dc.buffer()->length() >= len)) goto bad;
            objkey = dc.buffer()->data();
            dc.buffer()->rseek_rel (len);
        }
        if (!(dc.seq_end ())) goto bad;

        if (major > 1 || minor > 0)
            if (!(comps.decode (dc))) goto bad;

        ip = new UIOPProfile (objkey, len,
                              UnixAddress (filename.c_str()),
                              comps,
                              version,
                              tagid, host.c_str());






    }
    if (!(dc.struct_end ())) goto bad;
    return ip;

bad:
    if (ip)
        delete ip;
    return 0;
}



CORBA::Boolean
MICO::UIOPProfileDecoder::has_id (MICO::UIOPProfile::ProfileId id) const
{
    return CORBA::IORProfile::TAG_UNIX_IOP == id;
}

static MICO::UIOPProfileDecoder uiop_ior_decoder;






MICO::UnknownProfile::UnknownProfile (ProfileId id)
    : tagid (id)
{

    tagdata.push_back (0);
}

MICO::UnknownProfile::UnknownProfile (const UnknownProfile &p)
    : tagid (p.tagid), tagdata (p.tagdata)
{
}

MICO::UnknownProfile::~UnknownProfile ()
{
}

MICO::UnknownProfile &
MICO::UnknownProfile::operator= (const UnknownProfile &p)
{
    tagid = p.tagid;
    tagdata = p.tagdata;
    return *this;
}

void
MICO::UnknownProfile::encode (CORBA::DataEncoder &ec) const
{


    ec.buffer()->wseek_rel (-1);
    ec.put_octets (&tagdata[0], tagdata.size());
}

const CORBA::Address *
MICO::UnknownProfile::addr () const
{
    return 0;
}

MICO::UnknownProfile::ProfileId
MICO::UnknownProfile::id () const
{
    return tagid;
}

MICO::UnknownProfile::ProfileId
MICO::UnknownProfile::encode_id () const
{
    return tagid;
}

void
MICO::UnknownProfile::objectkey (CORBA::Octet *, CORBA::Long)
{
}

const CORBA::Octet *
MICO::UnknownProfile::objectkey (CORBA::Long &) const
{
    return 0;
}

CORBA::Boolean
MICO::UnknownProfile::reachable ()
{
    return 0;
}

void
MICO::UnknownProfile::print (ostream &o) const
{
  o << "Unknown Profile" << endl;
  o << " Profile Id:  " << tagid << endl;

    if (tagid != CORBA::IORProfile::TAG_MULTIPLE_COMPONENTS) {
      return;
    }

    o << " Components:  ";

    MICO::CDRDecoder dc;
    dc.buffer()->put (&tagdata[0], tagdata.size());


    CORBA::Octet bo;
    CORBA::Boolean r = dc.get_octet (bo);
    ((void) ((r) ? 0 : (__assert_fail ("r", "ior.cc", 1437, __PRETTY_FUNCTION__), 0)));
    dc.byteorder (bo ? CORBA::LittleEndian : CORBA::BigEndian);

    char buf[16];
    CORBA::ULong len, l, c=16;
    dc.seq_begin (len);

    for (CORBA::ULong i = 0; i < len; ++i) {
        dc.struct_begin ();
        {
            dc.get_ulong (l);

            sprintf (buf, "%lu", (unsigned long) l);
            if (c + strlen (buf) + 1 >= 80) {
              o << endl;
              o << "              ";
              c = 16;
            }
            else if (i > 0) {
              o << " ";
            }
            o << buf;
            c += strlen (buf) + 1;

            dc.seq_begin (l);
            if (!dc.buffer()->rseek_rel (l)) {
                o << endl << "bad component data" << endl;
                return;
            }
            dc.seq_end ();
        }
        dc.struct_end ();
    }
    dc.seq_end ();
    o << endl;
}

CORBA::IORProfile *
MICO::UnknownProfile::clone () const
{
    return new UnknownProfile (*this);
}

CORBA::Long
MICO::UnknownProfile::compare (const CORBA::IORProfile &p) const
{
    if (id() != p.id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();

    UnknownProfile &up = (UnknownProfile &)p;
    return mico_vec_compare (tagdata, up.tagdata);
}

CORBA::Boolean
MICO::UnknownProfile::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::UnknownProfile::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}

MICO::UnknownProfile *
MICO::UnknownProfile::decode (CORBA::DataDecoder &dc, ProfileId id,
                              CORBA::ULong len)
{
    if (len > 10000)

        return 0;

    if (dc.buffer()->length() < len)
        return 0;

    UnknownProfile *p = new UnknownProfile (id);

    p->tagdata.erase (p->tagdata.begin(), p->tagdata.end());

    p->tagdata.insert (p->tagdata.begin(),
                       dc.buffer()->data() - 1, dc.buffer()->data() + len);
    dc.buffer()->rseek_rel (len);

    return p;
}





CORBA::MultiComponent::MultiComponent ()
{
}

void
CORBA::MultiComponent::free ()
{
    for (mico_vec_size_type i = 0; i < _comps.size(); ++i)
        delete _comps[i];

    _comps.erase (_comps.begin(), _comps.end());
}

void
CORBA::MultiComponent::copy (const MultiComponent &mc)
{
    for (mico_vec_size_type i = 0; i < mc._comps.size(); ++i)
        _comps.push_back (mc._comps[i]->clone());
}

CORBA::MultiComponent::MultiComponent (const MultiComponent &mc)
{
    copy (mc);
}

CORBA::MultiComponent &
CORBA::MultiComponent::operator= (const MultiComponent &mc)
{
    if (this != &mc) {
        free ();
        copy (mc);
    }
    return *this;
}

CORBA::MultiComponent::~MultiComponent ()
{
    free ();
}

CORBA::Long
CORBA::MultiComponent::compare (const MultiComponent &mc) const
{
    int len = _comps.size() < mc._comps.size()
        ? _comps.size()
        : mc._comps.size();

    CORBA::Long r;
    for (int i = 0; i < len; ++i) {
        r = _comps[i]->compare (*mc._comps[i]);
        if (r)
            return r;
    }
    return _comps.size() - mc._comps.size();
}

CORBA::Boolean
CORBA::MultiComponent::operator< (const MultiComponent &mc) const
{
    return compare (mc) < 0;
}

CORBA::Boolean
CORBA::MultiComponent::operator== (const MultiComponent &mc) const
{
    return compare (mc) == 0;
}

void
CORBA::MultiComponent::add_component (Component *c)
{
    int i = _comps.size();
    while (--i >= 0 && *c < *_comps[i])
        ;
    _comps.insert (_comps.begin()+i+1, c);
}

void
CORBA::MultiComponent::del_component (Component *c)
{
    for (mico_vec_size_type i = 0; i < _comps.size(); ++i) {
        if (_comps[i] == c) {
            _comps.erase (_comps.begin()+i);
            break;
        }
    }
}

CORBA::Component *
CORBA::MultiComponent::component (ComponentId cid)
{
    for (mico_vec_size_type i = 0; i < _comps.size(); ++i) {
        if (_comps[i]->id() == cid)
            return _comps[i];
    }
    return 0;
}

void
CORBA::MultiComponent::encode (DataEncoder &ec) const
{
    CORBA::DataEncoder::EncapsState state;

    ec.seq_begin (_comps.size());
    for (mico_vec_size_type i = 0; i < _comps.size(); ++i) {
        ec.struct_begin ();
        ec.put_ulong (_comps[i]->id());
        ec.encaps_begin (state);
        _comps[i]->encode (ec);
        ec.encaps_end (state);
        ec.struct_end ();
    }
    ec.seq_end ();
}



CORBA::Boolean
CORBA::MultiComponent::decode (DataDecoder &dc)
{
    {
        free ();

        CORBA::ULong len;

        if (!(dc.seq_begin (len))) goto bad;
        for (ULong i = 0; i < len; ++i) {
            Component *comp = Component::decode (dc);
            if (!(comp)) goto bad;
            add_component (comp);
        }
        if (!(dc.seq_end ())) goto bad;
        return 1;
    }

bad:
    free ();
    return 0;
}



void
CORBA::MultiComponent::print (ostream &o) const
{
  if (_comps.size() > 0) {
    o << " Components:  ";
    for (mico_vec_size_type i = 0; i < _comps.size(); ++i) {
      if (i > 0) {
        o << "              ";
      }
      _comps[i]->print (o);
    }
  }
}

CORBA::ULong
CORBA::MultiComponent::size () const
{
    return _comps.size();
}





CORBA::ComponentDecoder::~ComponentDecoder ()
{
}






namespace CORBA {
  vector<CORBA::ComponentDecoder *> *Component::decoders = 0;
};




CORBA::Component::~Component ()
{
}

void
CORBA::Component::copy (Component *p)
{
}



CORBA::Component *
CORBA::Component::decode (DataDecoder &dc)
{
    ULong pid, len, next_pos;
    CORBA::DataDecoder::EncapsState state;
    Component *p = 0;

    if (!(dc.struct_begin ())) goto bad;
    if (!(dc.get_ulong (pid))) goto bad;
    if (!(dc.encaps_begin (state, len))) goto bad;

    next_pos = dc.buffer()->rpos() + len;
    p = decode_body (dc, (ComponentId)pid, len);

    if (!(dc.buffer()->rseek_beg (next_pos))) goto bad;

    if (!(p)) goto bad;
    if (!(dc.encaps_end (state))) goto bad;
    if (!(dc.struct_end ())) goto bad;
    return p;

bad:
    if (p)
        delete p;
    return 0;
}



CORBA::Component *
CORBA::Component::decode_body (DataDecoder &dc, ComponentId pid, ULong len)
{
    if (!decoders)
        decoders = new vector<CORBA::ComponentDecoder *>;

    ULong i;
    Component *p;

    for (i = 0; i < decoders->size(); ++i) {
        if ((*decoders)[i]->has_id ((CORBA::Component::ComponentId)pid))
            break;
    }
    if (i < decoders->size()) {

        p = (*decoders)[i]->decode (dc, (CORBA::Component::ComponentId)pid,
                                    len);
    } else {

        p = MICO::UnknownComponent::decode(
            dc, (CORBA::Component::ComponentId)pid, len);
    }
    return p;
}

void
CORBA::Component::register_decoder (ComponentDecoder *decoder)
{
    if (!decoders)
        decoders = new vector<CORBA::ComponentDecoder *>;
    decoders->push_back (decoder);
}

void
CORBA::Component::unregister_decoder (ComponentDecoder *decoder)
{
    if (!decoders)
        return;
    for (ULong i = 0; i < decoders->size(); ) {
        if ((*decoders)[i] == decoder)
            decoders->erase (decoders->begin() + i);
        else
            ++i;
    }
}





MICO::UnknownComponent::UnknownComponent (ComponentId id,
                                          CORBA::Octet *data,
                                          CORBA::ULong len)
    : tagid (id)
{
    if (data) {
        tagdata.insert (tagdata.end(), data, data+len);
    } else {

        tagdata.push_back (0);
    }
}

MICO::UnknownComponent::UnknownComponent (const UnknownComponent &p)
    : tagid (p.tagid), tagdata (p.tagdata)
{
}

MICO::UnknownComponent::~UnknownComponent ()
{
}

MICO::UnknownComponent &
MICO::UnknownComponent::operator= (const UnknownComponent &p)
{
    tagid = p.tagid;
    tagdata = p.tagdata;
    return *this;
}

void
MICO::UnknownComponent::encode (CORBA::DataEncoder &ec) const
{


    ec.buffer()->wseek_rel (-1);
    ec.put_octets (&tagdata[0], tagdata.size());
}

MICO::UnknownComponent::ComponentId
MICO::UnknownComponent::id () const
{
    return tagid;
}

void
MICO::UnknownComponent::print (ostream &o) const
{
  char buf[10];
  int j, k;

  o << "Unknown Component" << endl;
  o << "              Tag Id:  " << tagid << endl;
  o << "                 Tag:  ";

  for (j=0; j<tagdata.size(); j+=8) {
    for (k=0; k<j+8 && k<tagdata.size(); k++) {
      sprintf (buf, "%02x ", (int) tagdata[k]);
      o << buf;
    }
    for (; k<j+8; k++) {
      sprintf (buf, "   ");
      o << buf;
    }
    for (k=j; k<j+8 && k<tagdata.size(); k++) {
      if (isprint (tagdata[k])) {
        o << (char) tagdata[k];
      }
      else {
        o << '.';
      }
    }
    o << endl;

    if (k < tagdata.size()) {
      o << "                       ";
    }
  }
}

CORBA::Component *
MICO::UnknownComponent::clone () const
{
    return new UnknownComponent (*this);
}

CORBA::Long
MICO::UnknownComponent::compare (const CORBA::Component &p) const
{
    if (id() != p.id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();

    UnknownComponent &up = (UnknownComponent &)p;
    return mico_vec_compare (tagdata, up.tagdata);
}

CORBA::Boolean
MICO::UnknownComponent::operator== (const CORBA::Component &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::UnknownComponent::operator< (const CORBA::Component &p) const
{
    return compare (p) < 0;
}

MICO::UnknownComponent *
MICO::UnknownComponent::decode (CORBA::DataDecoder &dc, ComponentId id,
                                CORBA::ULong len)
{
    if (len > 10000)

        return 0;

    if (dc.buffer()->length() < len)
        return 0;

    UnknownComponent *p = new UnknownComponent (id);

    p->tagdata.erase (p->tagdata.begin(), p->tagdata.end());

    p->tagdata.insert (p->tagdata.begin(),
                       dc.buffer()->data() - 1, dc.buffer()->data() + len);
    dc.buffer()->rseek_rel (len);

    return p;
}





MICO::MultiCompProfile::MultiCompProfile (const CORBA::MultiComponent &mc,
                                          ProfileId tagid)
    : _mc (mc), _tagid (tagid)
{
}

MICO::MultiCompProfile::MultiCompProfile (const MultiCompProfile &mcp)
    : _mc (mcp._mc), _tagid (mcp._tagid)
{
}

MICO::MultiCompProfile::~MultiCompProfile ()
{
}

MICO::MultiCompProfile &
MICO::MultiCompProfile::operator= (const MultiCompProfile &mcp)
{
    if (this != &mcp) {
        _mc = mcp._mc;
        _tagid = mcp._tagid;
    }
    return *this;
}

void
MICO::MultiCompProfile::encode (CORBA::DataEncoder &ec) const
{
    _mc.encode (ec);
}

const CORBA::Address *
MICO::MultiCompProfile::addr () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "ior.cc", 1968, __PRETTY_FUNCTION__), 0)));
    return 0;
}

MICO::MultiCompProfile::ProfileId
MICO::MultiCompProfile::id () const
{
    return _tagid;
}

MICO::MultiCompProfile::ProfileId
MICO::MultiCompProfile::encode_id () const
{
    return _tagid;
}

void
MICO::MultiCompProfile::objectkey (CORBA::Octet *, CORBA::Long length)
{
}

const CORBA::Octet *
MICO::MultiCompProfile::objectkey (CORBA::Long &length) const
{
    length = 0;
    return (const CORBA::Octet *)"";
}

CORBA::Boolean
MICO::MultiCompProfile::reachable ()
{
    return 0;
}

void
MICO::MultiCompProfile::print (ostream &o) const
{
  o << "Multiple Components Profile" << endl;
  _mc.print (o);
}

CORBA::IORProfile *
MICO::MultiCompProfile::clone () const
{
    return new MultiCompProfile (*this);
}

CORBA::Long
MICO::MultiCompProfile::compare (const CORBA::IORProfile &p) const
{
    if (id() != p.id())
        return (CORBA::Long)id() - (CORBA::Long)p.id();

    MultiCompProfile &mcp = (MultiCompProfile &)p;

    return _mc.compare (mcp._mc);
}

CORBA::Boolean
MICO::MultiCompProfile::operator== (const CORBA::IORProfile &p) const
{
    return compare (p) == 0;
}

CORBA::Boolean
MICO::MultiCompProfile::operator< (const CORBA::IORProfile &p) const
{
    return compare (p) < 0;
}

CORBA::MultiComponent *
MICO::MultiCompProfile::components()
{
    return &_mc;
}





MICO::MultiCompProfileDecoder::MultiCompProfileDecoder (
    CORBA::IORProfile::ProfileId id)
{
    _tagid = id;
    CORBA::IORProfile::register_decoder (this);
}

MICO::MultiCompProfileDecoder::~MultiCompProfileDecoder ()
{
    CORBA::IORProfile::unregister_decoder (this);
}

CORBA::IORProfile *
MICO::MultiCompProfileDecoder::decode (CORBA::DataDecoder &dc,
                                       ProfileId id, CORBA::ULong) const
{
    CORBA::MultiComponent mc;
    if (!mc.decode (dc))
        return 0;

    return new MultiCompProfile (mc, id);
}

CORBA::Boolean
MICO::MultiCompProfileDecoder::has_id (ProfileId id) const
{
    return id == _tagid;
}





static MICO::MultiCompProfileDecoder multicomp_profile_decoder;
# 13 "orb_all.cc" 2
# 1 "object.cc" 1
# 25 "object.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "object.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "object.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 30 "object.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 31 "object.cc" 2
# 1 "../include/mico/util.h" 1
# 32 "object.cc" 2
# 1 "../include/mico/throw.h" 1
# 33 "object.cc" 2
# 41 "object.cc"
void
CORBA::MagicChecker::_check () const
{
    if (!this || magic != 0x31415927) {



        mico_throw (BAD_PARAM());
    }
}

void
CORBA::MagicChecker::_check (const CORBA::Exception &ex) const
{
    if (!this || magic != 0x31415927) {



        ((CORBA::Exception&)ex)._raise();
    }
}

CORBA::Boolean
CORBA::MagicChecker::_check_nothrow () const
{
    if (!this || magic != 0x31415927) {
      if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
        MICO::Logger::Stream (MICO::Logger::Warning)
          << "invalid object reference" << endl;
      }



      return 0;
    }
    return 1;
}





CORBA::ServerlessObject::~ServerlessObject ()
{
}

void
CORBA::ServerlessObject::_ref ()
{
    _check ();
    ++refs;
}

CORBA::Boolean
CORBA::ServerlessObject::_deref ()
{
    return _check_nothrow() && --refs <= 0;
}

CORBA::Long
CORBA::ServerlessObject::_refcnt () const
{
    _check ();
    return refs;
}






namespace CORBA {
    CORBA::Object_ptr OBJECT_NIL = 0;
}






CORBA::Object::Object (IOR *i)
{
    ior = i;
    fwd_ior = 0;
    orb = CORBA::ORB_instance ("mico-local-orb");
    ((void) ((orb) ? 0 : (__assert_fail ("orb", "object.cc", 126, __PRETTY_FUNCTION__), 0)));
}

CORBA::Object::Object (const Object &o)
{
    ior = o.ior ? new IOR (*o.ior) : 0;
    fwd_ior = o.fwd_ior ? new IOR (*o.fwd_ior) : 0;
    orb = CORBA::ORB::_duplicate (o.orb);
    _managers = o._managers;
    _policies = o._policies;
}

CORBA::Object &
CORBA::Object::operator= (const Object &o)
{
    (this)->_check ();

    if (this != &o) {
        if (ior)
            delete ior;
        ior = o.ior ? new IOR (*o.ior) : 0;
        if (fwd_ior)
            delete fwd_ior;
        fwd_ior = o.fwd_ior ? new IOR (*o.fwd_ior) : 0;
        CORBA::release (orb);
        orb = CORBA::ORB::_duplicate (o.orb);
        _managers = o._managers;
        _policies = o._policies;
    }
    return *this;
}

CORBA::Object::~Object ()
{
    if (ior)
        delete ior;
    if (fwd_ior)
        delete fwd_ior;
    CORBA::release (orb);
}

void
CORBA::Object::_forward (CORBA::Object_ptr o)
{
    ((void) ((!CORBA::is_nil (o) && o->ior) ? 0 : (__assert_fail ("!CORBA::is_nil (o) && o->ior", "object.cc", 170, __PRETTY_FUNCTION__), 0)));
    if (fwd_ior)
        delete fwd_ior;
    fwd_ior = new IOR (*o->ior);
}

void
CORBA::Object::_unforward ()
{
    if (fwd_ior) {
        delete fwd_ior;
        fwd_ior = 0;
    }
}

void
CORBA::Object::_setup_domains (CORBA::Object_ptr parent)
{
    if (CORBA::is_nil (parent)) {
        CORBA::DomainManager_var def_manager;
        orb->get_default_domain_manager (def_manager);

        _managers.length (1);

        CORBA::Policy_var p =
            def_manager->_get_policy (CORBA::SecConstruction);
        ((void) ((!CORBA::is_nil (p)) ? 0 : (__assert_fail ("!CORBA::is_nil (p)", "object.cc", 196, __PRETTY_FUNCTION__), 0)));

        CORBA::ConstructionPolicy_var cp =
            CORBA::ConstructionPolicy::_narrow (p);

        if (cp->constr_policy (this)) {
            _managers[0] = def_manager->copy();
        } else {
            _managers[0] = def_manager._retn();
        }
    } else {
        CORBA::DomainManagerList_var dml = parent->_get_domain_managers();
        _managers.length (dml->length());

        for (CORBA::ULong i = 0; i < dml->length(); ++i) {
            CORBA::Policy_var p =
                dml[i]->_get_policy (CORBA::SecConstruction);
            ((void) ((!CORBA::is_nil (p)) ? 0 : (__assert_fail ("!CORBA::is_nil (p)", "object.cc", 213, __PRETTY_FUNCTION__), 0)));

            CORBA::ConstructionPolicy_var cp =
                CORBA::ConstructionPolicy::_narrow (p);

            if (cp->constr_policy (this)) {
                _managers[i] = CORBA::DomainManager::_duplicate (dml[i]);
            } else {
                _managers[i] = dml[i]->copy();
            }
        }
    }
}

const char *
CORBA::Object::_ident ()
{
    IORProfile *prof = _ior()->profile (IORProfile::TAG_ANY);
    ((void) ((prof) ? 0 : (__assert_fail ("prof", "object.cc", 231, __PRETTY_FUNCTION__), 0)));
    Long len;
    const Octet *key = prof->objectkey (len);
    ident = "";
    for (int i = 0; i < len; ++i) {
        ident += mico_to_xdigit ((key[i] >> 4) & 0xf);
        ident += mico_to_xdigit (key[i] & 0xf);
    }
    return ident.c_str();
}

void *
CORBA::Object::_narrow_helper (const char *)
{
    return __null;
}

CORBA::ImplementationDef_ptr
CORBA::Object::_get_implementation ()
{
    return _orbnc()->get_impl (this);
}

CORBA::InterfaceDef_ptr
CORBA::Object::_get_interface ()
{
    (this)->_check (CORBA::OBJECT_NOT_EXIST());

    return _orbnc()->get_iface (this);
}

void
CORBA::Object::_create_request (Context_ptr ctx,
                                const char *op,
                                NVList_ptr args,
                                NamedValue_ptr result,
                                Request_out request,
                                Flags flags)
{
    request = new Request (this, ctx, op, args, result, flags);
}

void
CORBA::Object::_create_request (Context_ptr ctx,
                                const char *op,
                                NVList_ptr args,
                                NamedValue_ptr result,
                                ExceptionList_ptr elist,
                                ContextList_ptr clist,
                                Request_out request,
                                Flags flags)
{
    request = new Request (this, ctx, op, args, result, elist, clist, flags);
}

CORBA::Request_ptr
CORBA::Object::_request (const char *op)
{
    return new Request (this, op);
}

CORBA::Policy_ptr
CORBA::Object::_get_policy (PolicyType policy_type)
{

    for (CORBA::ULong i0 = 0; i0 < _policies.length(); ++i0) {
        if (_policies[i0]->policy_type() == policy_type)
            return CORBA::Policy::_duplicate (_policies[i0]);
    }

    for (CORBA::ULong i1 = 0; i1 < _managers.length(); ++i1) {
        CORBA::Policy_ptr p = _managers[i1]->_get_policy (policy_type);
        if (!CORBA::is_nil (p))
            return p;
    }
    mico_throw (CORBA::BAD_PARAM());
    return CORBA::Policy::_nil();
}

CORBA::DomainManagerList *
CORBA::Object::_get_domain_managers ()
{
    return new DomainManagerList (_managers);
}

CORBA::Object_ptr
CORBA::Object::_set_policy_overrides (const PolicyList &policies,
                                      SetOverrideType set_add)
{
    CORBA::Object_ptr nobj = new CORBA::Object (*this);
    switch (set_add) {
    case CORBA::SET_OVERRIDE:
        nobj->_policies = policies;
        break;

    case CORBA::ADD_OVERRIDE: {
        for (CORBA::ULong i = 0; i < policies.length(); ++i) {
            CORBA::ULong j;
            for (j = 0; j < nobj->_policies.length(); ++j) {
                if (nobj->_policies[j]->policy_type() ==
                      policies[i]->policy_type()) {
                    nobj->_policies[j] =
                        CORBA::Policy::_duplicate (policies[i].in());
                    break;
                }
            }
            if (j == nobj->_policies.length()) {
                nobj->_policies.length (j+1);
                nobj->_policies[j] = CORBA::Policy::_duplicate (policies[i].in());
            }
        }
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "object.cc", 345, __PRETTY_FUNCTION__), 0)));
    }
    return nobj;
}

CORBA::Boolean
CORBA::Object::_is_a (const char *repoid)
{
    (this)->_check (CORBA::OBJECT_NOT_EXIST());


    if (!strcmp (repoid, "IDL:omg.org/CORBA/Object:1.0"))
        return 1;
    if (!strcmp (repoid, _repoid()))
        return 1;


    if (_narrow_helper (repoid))
        return 1;

    return _is_a_remote (repoid);
}

CORBA::Boolean
CORBA::Object::_is_a_remote (const char *repoid)
{

    if (_orbnc()->is_impl (this))
        return 0;
    return _orbnc()->is_a (this, repoid);
}

CORBA::Boolean
CORBA::Object::_non_existent ()
{
    if (CORBA::is_nil (this))
        return 0;

    if (!_check_nothrow())
        return 1;

    return _orbnc()->non_existent (this);
}

CORBA::Boolean
CORBA::Object::_is_equivalent (Object_ptr o)
{
    if (CORBA::is_nil (this) && CORBA::is_nil (o))
        return 1;

    if (!CORBA::is_nil (this))
        (this)->_check (CORBA::OBJECT_NOT_EXIST());

    if (!CORBA::is_nil (o))
        (o)->_check (CORBA::OBJECT_NOT_EXIST());

    if (CORBA::is_nil (this) || CORBA::is_nil (o))
        return 0;

    if (this == o)
        return 1;
    return *_ior() == *o->_ior();
}

CORBA::ULong
CORBA::Object::_hash (ULong max)
{
    (this)->_check (CORBA::OBJECT_NOT_EXIST());

    string s = _ior()->stringify();
    return mico_string_hash (s.c_str(), max);
}
# 14 "orb_all.cc" 2
# 1 "value.cc" 1
# 23 "value.cc"
# 1 "../include/CORBA.h" 1
# 24 "value.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 26 "value.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 28 "value.cc" 2
# 1 "../include/mico/impl.h" 1
# 29 "value.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 30 "value.cc" 2
# 1 "../include/mico/util.h" 1
# 31 "value.cc" 2
# 1 "../include/mico/throw.h" 1
# 32 "value.cc" 2





CORBA::DefaultValueRefCountBase::DefaultValueRefCountBase ()
{
}

CORBA::DefaultValueRefCountBase::~DefaultValueRefCountBase ()
{
}

CORBA::SimpleValueRefCountBase::SimpleValueRefCountBase ()
{
}

CORBA::SimpleValueRefCountBase::~SimpleValueRefCountBase ()
{
}




CORBA::ValueBase::ValueBase ()
{
  _destructing = false;
}

CORBA::ValueBase::ValueBase (const ValueBase &)
{
  _destructing = false;
}

CORBA::ValueBase::~ValueBase ()
{
}

CORBA::ValueBase *
CORBA::ValueBase::_downcast (ValueBase *vb)
{
    return vb;
}

void *
CORBA::ValueBase::_narrow_helper (const char *)
{
  return 0;
}

CORBA::ValueBase *
CORBA::ValueBase::_create (const vector<string> &repoids,
                           const string &myrepoid)
{
    CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");

    if (repoids.size() == 0) {
        CORBA::ValueFactoryBase_var vf =
            orb->lookup_value_factory (myrepoid.c_str());
        if (vf.in()) {
          return vf->create_for_unmarshal();
        }
    } else {
        for (mico_vec_size_type i = 0; i < repoids.size(); ++i) {
            CORBA::ValueFactoryBase_var vf =
                orb->lookup_value_factory (repoids[i].c_str());
            if (vf.in()) {
              return vf->create_for_unmarshal();
            }
        }
    }
    mico_throw (MARSHAL());
    return 0;
}

void
CORBA::ValueBase::_marshal (CORBA::DataEncoder &ec, ValueBase *vb)
{
    if (!vb) {

        ec.value_ref (0);
        return;
    }
    CORBA::DataEncoder::MapValueId::iterator it =
        ec.valuestate()->visited.find (vb);
    if (it != ec.valuestate()->visited.end()) {

        ec.value_ref ((*it).second);
        return;
    }

    vector<string> repoids;
    CORBA::Boolean chunked;
    vb->_get_marshal_info (repoids, chunked);

    Long vid;
    ec.value_begin ("", repoids, chunked, vid);
    ec.valuestate()->visited[vb] = vid;

    vb->_marshal_members (ec);

    ec.value_end (vid);
}

CORBA::Boolean
CORBA::ValueBase::_demarshal (CORBA::DataDecoder &dc, ValueBase *&vb,
                              const string &repoid)
{
    string url;
    vector<string> repoids;
    CORBA::Long vid;
    CORBA::Boolean is_ref;

    if (!dc.value_begin (url, repoids, vid, is_ref))
        return 0;

    if (is_ref) {
        if (!vid) {

            vb = 0;
            return 1;
        }

        CORBA::DataDecoder::MapIdValue::iterator it =
            dc.valuestate()->visited.find (vid);
        if (it == dc.valuestate()->visited.end())

            return 0;
        vb = (*it).second;
        CORBA::add_ref (vb);
        return 1;
    }

    vb = CORBA::ValueBase::_create (repoids, repoid);
    if (!vb)

        return 0;

    dc.valuestate()->visited[vid] = vb;

    if (!vb->_demarshal_members (dc))
        return 0;

    return dc.value_end (vid);
}

CORBA::ValueBase *
CORBA::ValueBase::_copy_value ()
{
  MICO::CDREncoder ec;
  MICO::CDRDecoder dc (ec.buffer(), 0, ec.byteorder(),
                       ec.converter(), 0);
  CORBA::DataEncoder::ValueState evstate;
  CORBA::DataDecoder::ValueState dvstate;

  CORBA::ValueBase * res;
  CORBA::Boolean ret;
  vector<string> repoids;

  ec.valuestate (&evstate, 0);
  dc.valuestate (&dvstate, 0);
  _get_marshal_info (repoids, ret);

  _marshal (ec, this);
  ret = _demarshal (dc, res, repoids[0]);
  ((void) ((ret) ? 0 : (__assert_fail ("ret", "value.cc", 197, __PRETTY_FUNCTION__), 0)));
  return res;
}

void
CORBA::ValueBase::_get_marshal_info (vector<string> &, Boolean &)
{

    ((void) ((0) ? 0 : (__assert_fail ("0", "value.cc", 205, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::ValueBase::_marshal_members (DataEncoder &)
{

    ((void) ((0) ? 0 : (__assert_fail ("0", "value.cc", 212, __PRETTY_FUNCTION__), 0)));
}

CORBA::Boolean
CORBA::ValueBase::_demarshal_members (DataDecoder &)
{

    ((void) ((0) ? 0 : (__assert_fail ("0", "value.cc", 219, __PRETTY_FUNCTION__), 0)));
    return 0;
}

CORBA::Long
CORBA::ValueBase::_count_refs (visited *)
{
  return 0;
}

void
CORBA::ValueBase::_release_members ()
{
}




CORBA::ValueFactoryBase::ValueFactoryBase ()
{
}

CORBA::ValueFactoryBase::~ValueFactoryBase ()
{
}

CORBA::ValueFactory
CORBA::ValueFactoryBase::_downcast (ValueFactory vf)
{
  return vf;
}

void *
CORBA::ValueFactoryBase::_narrow_helper (const char *)
{
  return 0;
}





CORBA::ValueFactory
CORBA::ORB::register_value_factory (const char *repoid, ValueFactory factory)
{
    ValueFactory vf = lookup_value_factory (repoid);
    factory->_add_ref();
    _value_facs[repoid] = factory;
    return vf;
}

void
CORBA::ORB::unregister_value_factory (const char *repoid)
{
    _value_facs.erase (repoid);
}

CORBA::ValueFactory
CORBA::ORB::lookup_value_factory (const char *repoid)
{
    ValueFactoryMap::iterator i = _value_facs.find (repoid);
    if (i == _value_facs.end())
        return 0;
    ValueFactory vf = (*i).second.in();
    vf->_add_ref();
    return vf;
}





CORBA::AbstractBase::AbstractBase ()
{
}

CORBA::AbstractBase::AbstractBase (const AbstractBase &)
{
}

CORBA::AbstractBase::~AbstractBase ()
{
}

CORBA::AbstractBase_ptr
CORBA::AbstractBase::_duplicate (AbstractBase_ptr ab)
{
  if (!CORBA::is_nil (ab)) {
    Object_ptr obj = ab->_to_object ();
    ValueBase * val = ab->_to_value ();
    if (!CORBA::is_nil (obj)) {
      obj = Object::_duplicate (obj);
    }
    else if (val != 0) {
      CORBA::add_ref (val);
    }
  }

  return ab;
}

CORBA::AbstractBase_ptr
CORBA::AbstractBase::_narrow (AbstractBase_ptr ab)
{
  return _duplicate (ab);
}

CORBA::Object_ptr
CORBA::AbstractBase::_to_object ()
{
  return Object::_nil ();
}

CORBA::ValueBase *
CORBA::AbstractBase::_to_value ()
{
  return 0;
}

void
CORBA::AbstractBase::_marshal (DataEncoder &ec, AbstractBase *ab)
{
  Object_ptr obj;
  ValueBase * val;

  if (!CORBA::is_nil (ab)) {
    obj = ab->_to_object ();
    val = ab->_to_value ();
  }
  else {
    obj = Object::_nil ();
    val = 0;
  }

  ec.union_begin();
  if (!CORBA::is_nil (obj)) {
    ec.put_boolean (1);
    CORBA::_stc_Object->marshal( ec, &obj );
  }
  else {
    ec.put_boolean (0);
    CORBA::_stc_ValueBase->marshal( ec, &val );
  }
  ec.union_end();
}

CORBA::Boolean
CORBA::AbstractBase::_demarshal (DataDecoder &dc, AbstractBase *&ab)
{
  Boolean is_objref;

  if (!dc.union_begin()) {
    return 0;
  }
  if (!CORBA::_stc_boolean->demarshal (dc, &is_objref)) {
    return 0;
  }
  if (is_objref) {
    Object_ptr obj;
    if (!CORBA::_stc_Object->demarshal (dc, &obj)) {
      return 0;
    }
    ab = new UnknownAbstract (obj, 0);
  }
  else {
    ValueBase * val;
    if (!CORBA::_stc_ValueBase->demarshal (dc, &val)) {
      return 0;
    }
    if (val) {
      ab = new UnknownAbstract (Object::_nil(), val);
    }
    else {
      ab = 0;
    }
  }

  return dc.union_end();
}

void *
CORBA::AbstractBase::_narrow_helper (const char *)
{
  return 0;
}

void
CORBA::release (AbstractBase_ptr ab)
{
  if (!CORBA::is_nil (ab)) {
    Object_ptr obj = ab->_to_object ();
    ValueBase * val = ab->_to_value ();
    if (!CORBA::is_nil (obj)) {
      CORBA::release (obj);
    }
    else if (val != 0) {
      CORBA::remove_ref (val);
    }
  }
}

CORBA::MixedBase::~MixedBase ()
{
}

CORBA::UnknownAbstract::UnknownAbstract (CORBA::Object_ptr _o,
                                         CORBA::ValueBase * _v)
{
  obj = _o;
  val = _v;
}

CORBA::UnknownAbstract::~UnknownAbstract ()
{
}

CORBA::Object_ptr
CORBA::UnknownAbstract::_to_object ()
{
  return obj;
}

CORBA::ValueBase *
CORBA::UnknownAbstract::_to_value ()
{
  return val;
}

void *
CORBA::UnknownAbstract::_narrow_helper (const char * repoid)
{
  if (!CORBA::is_nil (obj)) {
    return obj->_narrow_helper (repoid);
  }
  if (val) {
    return val->_narrow_helper (repoid);
  }
  return 0;
}
# 15 "orb_all.cc" 2
# 1 "valuetype_impl.cc" 1
# 23 "valuetype_impl.cc"
# 1 "../include/CORBA.h" 1
# 24 "valuetype_impl.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 25 "valuetype_impl.cc" 2





CORBA::ValueBase *
CORBA::StringValue_Factory::create_for_unmarshal ()
{
  return new CORBA::StringValue;
}

CORBA::ValueBase *
CORBA::WStringValue_Factory::create_for_unmarshal ()
{
  return new CORBA::WStringValue;
}





CORBA::DataOutputStream_impl::DataOutputStream_impl (DataEncoder &_ec)
{
  ec = &_ec;
}

CORBA::DataOutputStream_impl::~DataOutputStream_impl ()
{
}

void
CORBA::DataOutputStream_impl::write_any (const Any & value)
{
  ec->put_any (value);
}

void
CORBA::DataOutputStream_impl::write_boolean (Boolean value)
{
  ec->put_boolean (value);
}

void
CORBA::DataOutputStream_impl::write_char (Char value)
{
  ec->put_char (value);
}

void
CORBA::DataOutputStream_impl::write_wchar (WChar value)
{
  ec->put_wchar (value);
}

void
CORBA::DataOutputStream_impl::write_octet (Octet value)
{
  ec->put_octet (value);
}

void
CORBA::DataOutputStream_impl::write_short (Short value)
{
  ec->put_short (value);
}

void
CORBA::DataOutputStream_impl::write_ushort (UShort value)
{
  ec->put_ushort (value);
}

void
CORBA::DataOutputStream_impl::write_long (Long value)
{
  ec->put_long (value);
}

void
CORBA::DataOutputStream_impl::write_ulong (ULong value)
{
  ec->put_ulong (value);
}

void
CORBA::DataOutputStream_impl::write_longlong (LongLong value)
{
  ec->put_longlong (value);
}

void
CORBA::DataOutputStream_impl::write_ulonglong (ULongLong value)
{
  ec->put_ulonglong (value);
}

void
CORBA::DataOutputStream_impl::write_float (Float value)
{
  ec->put_float (value);
}

void
CORBA::DataOutputStream_impl::write_double (Double value)
{
  ec->put_double (value);
}

void
CORBA::DataOutputStream_impl::write_longdouble (LongDouble value)
{
  ec->put_longdouble (value);
}

void
CORBA::DataOutputStream_impl::write_string (const char * value)
{
  ec->put_string (value);
}

void
CORBA::DataOutputStream_impl::write_wstring (const WChar * value)
{
  ec->put_wstring (value);
}

void
CORBA::DataOutputStream_impl::write_Object (Object_ptr value)
{
  _stc_Object->marshal (*ec, &value);
}

void
CORBA::DataOutputStream_impl::write_Abstract (AbstractBase* value)
{
  _stc_AbstractBase->marshal (*ec, &value);
}

void
CORBA::DataOutputStream_impl::write_Value (ValueBase* value)
{
  _stc_ValueBase->marshal (*ec, &value);
}

void
CORBA::DataOutputStream_impl::write_TypeCode (TypeCode_ptr value)
{
  _stc_TypeCode->marshal (*ec, &value);
}

void
CORBA::DataOutputStream_impl::write_any_array (const AnySeq& seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  for (ULong i=0; i<length; i++) {
    write_any (seq[offset+i]);
  }
}

void
CORBA::DataOutputStream_impl::write_boolean_array (const BooleanSeq& seq,
                                                   CORBA::ULong offset,
                                                   CORBA::ULong length)
{
  if (length > 0)
    ec->put_booleans (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_char_array (const CharSeq& seq,
                                                CORBA::ULong offset,
                                                CORBA::ULong length)
{
  if (length > 0)
    ec->put_chars (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_wchar_array (const WCharSeq& seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (length > 0)
    ec->put_wchars (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_octet_array (const OctetSeq& seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (length > 0)
    ec->put_octets (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_short_array (const ShortSeq& seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (length > 0)
    ec->put_shorts (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_ushort_array (const UShortSeq& seq,
                                                  CORBA::ULong offset,
                                                  CORBA::ULong length)
{
  if (length > 0)
    ec->put_ushorts (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_long_array (const LongSeq& seq,
                                                CORBA::ULong offset,
                                                CORBA::ULong length)
{
  if (length > 0)
    ec->put_longs (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_ulong_array (const ULongSeq& seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (length > 0)
    ec->put_ulongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_longlong_array (const LongLongSeq& seq,
                                                    CORBA::ULong offset,
                                                    CORBA::ULong length)
{
  if (length > 0)
    ec->put_longlongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_ulonglong_array (const ULongLongSeq& seq,
                                                     CORBA::ULong offset,
                                                     CORBA::ULong length)
{
  if (length > 0)
    ec->put_ulonglongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_float_array (const FloatSeq& seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (length > 0)
    ec->put_floats (seq.get_buffer()+offset, length);
}

void
CORBA::DataOutputStream_impl::write_double_array (const DoubleSeq& seq,
                                                  CORBA::ULong offset,
                                                  CORBA::ULong length)
{
  if (length > 0)
    ec->put_doubles (seq.get_buffer()+offset, length);
}





CORBA::DataInputStream_impl::DataInputStream_impl (DataDecoder &_dc)
{
  dc = &_dc;
  okay = 1;
}

CORBA::DataInputStream_impl::~DataInputStream_impl ()
{
}

CORBA::Boolean
CORBA::DataInputStream_impl::is_okay () const
{
  return okay;
}

CORBA::Any *
CORBA::DataInputStream_impl::read_any ()
{
  Any * value = new Any;
  okay &= dc->get_any (*value);
  return value;
}

CORBA::Boolean
CORBA::DataInputStream_impl::read_boolean ()
{
  Boolean value;
  okay &= dc->get_boolean (value);
  return value;
}

CORBA::Char
CORBA::DataInputStream_impl::read_char ()
{
  Char value;
  okay &= dc->get_char (value);
  return value;
}

CORBA::WChar
CORBA::DataInputStream_impl::read_wchar ()
{
  WChar value;
  okay &= dc->get_wchar (value);
  return value;
}

CORBA::Octet
CORBA::DataInputStream_impl::read_octet ()
{
  Octet value;
  okay &= dc->get_octet (value);
  return value;
}

CORBA::Short
CORBA::DataInputStream_impl::read_short ()
{
  Short value;
  okay &= dc->get_short (value);
  return value;
}

CORBA::UShort
CORBA::DataInputStream_impl::read_ushort ()
{
  UShort value;
  okay &= dc->get_ushort (value);
  return value;
}

CORBA::Long
CORBA::DataInputStream_impl::read_long ()
{
  Long value;
  okay &= dc->get_long (value);
  return value;
}

CORBA::ULong
CORBA::DataInputStream_impl::read_ulong ()
{
  ULong value;
  okay &= dc->get_ulong (value);
  return value;
}

CORBA::LongLong
CORBA::DataInputStream_impl::read_longlong ()
{
  LongLong value;
  okay &= dc->get_longlong (value);
  return value;
}

CORBA::ULongLong
CORBA::DataInputStream_impl::read_ulonglong ()
{
  ULongLong value;
  okay &= dc->get_ulonglong (value);
  return value;
}

CORBA::Float
CORBA::DataInputStream_impl::read_float ()
{
  Float value;
  okay &= dc->get_float (value);
  return value;
}

CORBA::Double
CORBA::DataInputStream_impl::read_double ()
{
  Double value;
  okay &= dc->get_double (value);
  return value;
}

CORBA::LongDouble
CORBA::DataInputStream_impl::read_longdouble ()
{
  LongDouble value;
  okay &= dc->get_longdouble (value);
  return value;
}

char *
CORBA::DataInputStream_impl::read_string ()
{
  char * value;
  okay &= dc->get_string (value);
  return value;
}

CORBA::WChar *
CORBA::DataInputStream_impl::read_wstring ()
{
  WChar * value;
  okay &= dc->get_wstring (value);
  return value;
}

CORBA::Object_ptr
CORBA::DataInputStream_impl::read_Object ()
{
  Object_ptr value;
  okay &= _stc_Object->demarshal (*dc, &value);
  return value;
}

CORBA::AbstractBase*
CORBA::DataInputStream_impl::read_Abstract ()
{
  AbstractBase* value;
  okay &= _stc_AbstractBase->demarshal (*dc, &value);
  return value;
}

CORBA::ValueBase*
CORBA::DataInputStream_impl::read_Value ()
{
  ValueBase* value;
  okay &= _stc_ValueBase->demarshal (*dc, &value);
  return value;
}

CORBA::TypeCode_ptr
CORBA::DataInputStream_impl::read_TypeCode ()
{
  TypeCode_ptr value;
  okay &= _stc_TypeCode->demarshal (*dc, &value);
  return value;
}

void
CORBA::DataInputStream_impl::read_any_array (AnySeq &seq,
                                             CORBA::ULong offset,
                                             CORBA::ULong length)
{
  for (ULong i=0; i<length; i++) {
    okay &= dc->get_any (seq[offset+i]);
  }
}

void
CORBA::DataInputStream_impl::read_boolean_array (BooleanSeq &seq,
                                                 CORBA::ULong offset,
                                                 CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_booleans (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_char_array (CharSeq &seq,
                                              CORBA::ULong offset,
                                              CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_chars (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_wchar_array (WCharSeq &seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_wchars (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_octet_array (OctetSeq &seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_octets (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_short_array (ShortSeq &seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_shorts (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_ushort_array (UShortSeq &seq,
                                                CORBA::ULong offset,
                                                CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_ushorts (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_long_array (LongSeq &seq,
                                              CORBA::ULong offset,
                                              CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_longs (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_ulong_array (ULongSeq &seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_ulongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_longlong_array (LongLongSeq &seq,
                                                  CORBA::ULong offset,
                                                  CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_longlongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_ulonglong_array (ULongLongSeq &seq,
                                                   CORBA::ULong offset,
                                                   CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_ulonglongs (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_float_array (FloatSeq &seq,
                                               CORBA::ULong offset,
                                               CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_floats (seq.get_buffer()+offset, length);
}

void
CORBA::DataInputStream_impl::read_double_array (DoubleSeq &seq,
                                                CORBA::ULong offset,
                                                CORBA::ULong length)
{
  if (seq.length() < offset+length) {
    seq.length (offset+length);
  }
  if (length > 0)
    dc->get_doubles (seq.get_buffer()+offset, length);
}
# 16 "orb_all.cc" 2
# 1 "orb.cc" 1
# 23 "orb.cc"
# 1 "../include/CORBA.h" 1
# 24 "orb.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 26 "orb.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 28 "orb.cc" 2
# 1 "../include/mico/os-net.h" 1
# 29 "orb.cc" 2
# 1 "../include/mico/impl.h" 1
# 30 "orb.cc" 2
# 1 "../include/mico/ssl.h" 1
# 31 "orb.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 32 "orb.cc" 2
# 1 "../include/mico/util.h" 1
# 33 "orb.cc" 2
# 1 "../include/mico/poa_impl.h" 1
# 27 "../include/mico/poa_impl.h"
# 1 "../include/CORBA.h" 1
# 28 "../include/mico/poa_impl.h" 2
# 1 "../include/mico/impl.h" 1
# 29 "../include/mico/poa_impl.h" 2






template<class T, class V>
class POA_Policy :
  virtual public T,
  virtual public MICO::Policy_impl
{
private:
  V _value;

public:
  POA_Policy (CORBA::PolicyType t, V val)
      : MICO::Policy_impl (t), _value (val) {};
  V value () { return _value; };

  CORBA::Policy_ptr copy ()
  {
    return new POA_Policy<T,V> (policy_type(), _value);
  }
};
# 62 "../include/mico/poa_impl.h"
namespace MICOPOA {

extern void _init ();

class POA_impl;
class POACurrent_impl;






class POAOptions {
public:
  CORBA::Boolean parse (CORBA::ORB_ptr, int &, char *[]);
  const char * operator[] (const char *);

private:
  map<string,string,less<string> > options;
};

extern POAOptions poaopts;
# 93 "../include/mico/poa_impl.h"
typedef POA_Policy<PortableServer::ThreadPolicy, PortableServer::ThreadPolicyValue> ThreadPolicy_impl;
typedef POA_Policy<PortableServer::LifespanPolicy, PortableServer::LifespanPolicyValue> LifespanPolicy_impl;
typedef POA_Policy<PortableServer::IdUniquenessPolicy, PortableServer::IdUniquenessPolicyValue> IdUniquenessPolicy_impl;
typedef POA_Policy<PortableServer::IdAssignmentPolicy, PortableServer::IdAssignmentPolicyValue> IdAssignmentPolicy_impl;
typedef POA_Policy<PortableServer::ImplicitActivationPolicy, PortableServer::ImplicitActivationPolicyValue> ImplicitActivationPolicy_impl;
typedef POA_Policy<PortableServer::ServantRetentionPolicy, PortableServer::ServantRetentionPolicyValue> ServantRetentionPolicy_impl;
typedef POA_Policy<PortableServer::RequestProcessingPolicy, PortableServer::RequestProcessingPolicyValue> RequestProcessingPolicy_impl;
# 109 "../include/mico/poa_impl.h"
class POAManager_impl : virtual public PortableServer::POAManager
{
private:
  State _state;
  vector<PortableServer::POA_ptr> managed;
  void change_state (State,
                     CORBA::Boolean = 0,
                     CORBA::Boolean = 0);

public:
  POAManager_impl ();
  virtual ~POAManager_impl ();

  void activate ();
  void hold_requests (CORBA::Boolean);
  void discard_requests (CORBA::Boolean);
  void deactivate (CORBA::Boolean, CORBA::Boolean);
  State get_state ();


  void add_managed_poa (PortableServer::POA_ptr);
  void del_managed_poa (PortableServer::POA_ptr);

};
# 149 "../include/mico/poa_impl.h"
class ObjectId {
public:
  ObjectId ();
  ObjectId (const ObjectId &, bool = true);
  ObjectId (const PortableServer::ObjectId &);
  ObjectId (const char *, CORBA::ULong, bool = true);
  ~ObjectId ();

  ObjectId & operator= (const ObjectId &);
  CORBA::Boolean operator== (const ObjectId &);
  bool operator< (const ObjectId &) const;


  const char * get_data (CORBA::ULong &) const;
  const PortableServer::ObjectId & get_id ();


  PortableServer::ObjectId * id ();

private:
  bool own;
  char * octets;
  CORBA::ULong idlength;
  PortableServer::ObjectId * oid;
};
# 183 "../include/mico/poa_impl.h"
class POAObjectReference {
public:
  POAObjectReference (POA_impl *,
                      const PortableServer::ObjectId &,
                      const char *,
                      PortableServer::Servant = __null);
  POAObjectReference (POA_impl *, CORBA::Object_ptr);
  POAObjectReference (const POAObjectReference &);
  ~POAObjectReference ();

  bool is_legal ();

  POAObjectReference & operator= (const CORBA::Object_ptr);
  POAObjectReference & operator= (const POAObjectReference &);


  const ObjectId & get_oid ();
  CORBA::Object_ptr get_ref ();
  void set_ref (CORBA::Object_ptr);
  const PortableServer::ObjectId & get_id ();


  CORBA::Object_ptr ref ();
  PortableServer::ObjectId * id ();


  const char * poa_name ();
  bool in_poa (const char *);
  bool in_descendant_poa (const char *, const char *);
  char * next_descendant_poa (const char *, const char *);

private:
  void make_ref ();
  bool decompose_ref ();





  POA_impl * poa;





  bool iddirty;
  string poaname;
  string repoid;
  MICOPOA::ObjectId oid;
  CORBA::Object_ptr obj;
  PortableServer::Servant servant;
};
# 243 "../include/mico/poa_impl.h"
class ObjectMap {
public:
  struct ObjectRecord {
    ObjectRecord (POAObjectReference *,
                  PortableServer::Servant = __null);
    ~ObjectRecord ();
    POAObjectReference * por;
    PortableServer::Servant serv;
  };

  typedef map<ObjectId, ObjectRecord *, less<ObjectId> > IdMap;
  typedef IdMap::iterator iterator;

public:
  ~ObjectMap ();

  bool empty () const;
  void clear ();

  iterator begin ();
  iterator end ();

  ObjectRecord * pop ();

  void add (POAObjectReference *, PortableServer::Servant);
  ObjectRecord * del (const ObjectId &);
  ObjectRecord * del (const PortableServer::ObjectId &);

  bool exists (const ObjectId &);
  bool exists (const PortableServer::ObjectId &);
  bool exists (const POAObjectReference &);
  bool exists (PortableServer::Servant);

  ObjectRecord * find (const ObjectId &);
  ObjectRecord * find (const PortableServer::ObjectId &);
  ObjectRecord * find (const POAObjectReference &);
  ObjectRecord * find (POA_impl *, CORBA::Object_ptr);
  ObjectRecord * find (PortableServer::Servant);

private:
  typedef map<PortableServer::Servant, vector<ObjectRecord *>,
    less<PortableServer::Servant> > SvMap;

  IdMap objs;
  SvMap servants;
};





class UniqueIdGenerator {
public:
  UniqueIdGenerator ();
  UniqueIdGenerator (const char *);
  ~UniqueIdGenerator ();

  char * new_id ();

  char * state ();
  void state (const char *);

private:
  int ulen, pfxlen;
  char * uid;
  char * prefix;
};
# 323 "../include/mico/poa_impl.h"
class POA_impl : public PortableServer::POA,
                 public CORBA::ObjectAdapter
{
public:




  class InvocationRecord;
  typedef InvocationRecord *InvocationRecord_ptr;
  typedef ObjVar<InvocationRecord> InvocationRecord_var;

  class InvocationRecord : public CORBA::ServerlessObject {
  public:
    InvocationRecord (CORBA::ORB::MsgId,
                      POAObjectReference *,
                      CORBA::ORBRequest *,
                      CORBA::Principal_ptr);
    ~InvocationRecord ();

    void exec (POA_impl *);

    CORBA::ORB::MsgId id ();
    CORBA::ORBRequest * get_or ();
    POAObjectReference * get_por ();
    CORBA::ServerRequestBase_ptr make_req (POA_impl *,
                                           PortableServer::Servant);
    CORBA::ServerRequest_ptr make_dyn_req (POA_impl *);

    static InvocationRecord_ptr _duplicate (InvocationRecord_ptr o)
    {
      if (o)
        o->_ref();
      return o;
    }
    static InvocationRecord_ptr _nil ()
    {
      return 0;
    }

  private:
    CORBA::ORB::MsgId msgid;
    POAObjectReference * por;
    CORBA::ORBRequest * req;
    CORBA::Principal_ptr pr;
    CORBA::ServerRequestBase_ptr svr;
  };

private:




  PortableServer::ThreadPolicy_var thread_policy;
  PortableServer::LifespanPolicy_var lifespan_policy;
  PortableServer::IdUniquenessPolicy_var id_uniqueness_policy;
  PortableServer::IdAssignmentPolicy_var id_assignment_policy;
  PortableServer::ImplicitActivationPolicy_var implicit_activation_policy;
  PortableServer::ServantRetentionPolicy_var servant_retention_policy;
  PortableServer::RequestProcessingPolicy_var request_processing_policy;





  string name;
  string fqn;
  string oaid;
  static string oaprefix;

  POA_impl * parent;
  PortableServer::POAManager_ptr manager;
  PortableServer::Servant default_servant;
  PortableServer::ServantManager_var servant_manager;
  PortableServer::AdapterActivator_var adapter_activator;





  static string impl_name;
  static CORBA::IOR poamed_ior;
  static CORBA::POAMediator_var poamed;
  static CORBA::Boolean ever_been_active;





  int destructed;
  CORBA::ULong unique_id;
  CORBA::ORB_ptr orb;
  ObjectMap ActiveObjectMap;
  vector<InvocationRecord_ptr> InvocationQueue;
  PortableServer::POAManager::State state;





  typedef map<string, POA_impl *, less<string> > POAMap;

  void register_child (const char *, POA_impl *);
  void unregister_child (const char *);

  POAMap children;





  static void register_poa (const char *, POA_impl *);
  static void unregister_poa (const char *);

  static POAMap AllPOAs;
  static UniqueIdGenerator poauid;
  static UniqueIdGenerator idfactory;





  static POACurrent_impl * current;





  void set_policies (const CORBA::PolicyList &);
  void etherealize ();

  POA_impl * _find_POA (const char *, CORBA::Boolean);





  POA_impl (const char *,
            PortableServer::POAManager_ptr,
            const CORBA::PolicyList &,
            POA_impl *,
            CORBA::ORB_ptr);

public:
  POA_impl (CORBA::ORB_ptr);
  virtual ~POA_impl ();





  PortableServer::POA_ptr create_POA (const char *,
                                      PortableServer::POAManager_ptr,
                                      const CORBA::PolicyList &);
  PortableServer::POA_ptr find_POA (const char *,
                                      CORBA::Boolean);
  void destroy (CORBA::Boolean, CORBA::Boolean);





  char * the_name ();
  PortableServer::POA_ptr the_parent ();
  PortableServer::POAManager_ptr the_POAManager ();
  PortableServer::AdapterActivator_ptr the_activator ();
  PortableServer::POAList * the_children ();
  void the_activator (PortableServer::AdapterActivator_ptr);





  PortableServer::ThreadPolicy_ptr create_thread_policy (PortableServer::ThreadPolicyValue);
  PortableServer::LifespanPolicy_ptr create_lifespan_policy (PortableServer::LifespanPolicyValue);
  PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy (PortableServer::IdUniquenessPolicyValue);
  PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy (PortableServer::IdAssignmentPolicyValue);
  PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy (PortableServer::ImplicitActivationPolicyValue);
  PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy (PortableServer::ServantRetentionPolicyValue);
  PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy (PortableServer::RequestProcessingPolicyValue);





  PortableServer::ServantManager_ptr get_servant_manager ();
  void set_servant_manager (PortableServer::ServantManager_ptr);





  PortableServer::Servant get_servant ();
  void set_servant (PortableServer::Servant);





  PortableServer::ObjectId * activate_object (PortableServer::Servant);
  void activate_object_with_id (const PortableServer::ObjectId &,
                                PortableServer::Servant);

  void deactivate_object (const PortableServer::ObjectId &);





  CORBA::Object_ptr create_reference (const char *);
  CORBA::Object_ptr create_reference_with_id (const PortableServer::ObjectId &,
                                              const char *);





  CORBA::Object_ptr activate_for_this (PortableServer::Servant);





  CORBA::IOR * ior_template ();





  PortableServer::ObjectId * servant_to_id (PortableServer::Servant);
  CORBA::Object_ptr servant_to_reference (PortableServer::Servant);
  PortableServer::Servant reference_to_servant (CORBA::Object_ptr);
  PortableServer::ObjectId * reference_to_id (CORBA::Object_ptr);
  PortableServer::Servant id_to_servant (const PortableServer::ObjectId &);
  CORBA::Object_ptr id_to_reference (const PortableServer::ObjectId &);





  void poa_manager_callback (PortableServer::POAManager::State,
                             CORBA::Boolean, CORBA::Boolean);





  PortableServer::Servant preinvoke (CORBA::Object_ptr);
  void postinvoke ();





  const char * get_oaid () const;
  CORBA::Boolean has_object (CORBA::Object_ptr);
  CORBA::Boolean is_local () const;

  CORBA::Boolean invoke (CORBA::ORB::MsgId,
                         CORBA::Object_ptr,
                         CORBA::ORBRequest *,
                         CORBA::Principal_ptr,
                         CORBA::Boolean = 1);
  CORBA::Boolean bind (CORBA::ORB::MsgId, const char *,
                         const CORBA::ORB::ObjectTag &,
                         CORBA::Address *);
  CORBA::Boolean locate (CORBA::ORB::MsgId, CORBA::Object_ptr);
  CORBA::Object_ptr skeleton (CORBA::Object_ptr);

  void cancel (MsgId);
  void shutdown (CORBA::Boolean);

  void answer_invoke (CORBA::ORB::MsgId, CORBA::Object_ptr,
                      CORBA::ORBRequest *,
                      CORBA::InvokeStatus);





  void builtin_is_a (InvocationRecord_ptr, PortableServer::Servant);
  void builtin_interface (InvocationRecord_ptr, PortableServer::Servant);
  void builtin_non_existent (InvocationRecord_ptr, PortableServer::Servant);
  bool builtin_invoke (InvocationRecord_ptr, PortableServer::Servant);

  bool is_builtin (InvocationRecord_ptr);
  void local_invoke (InvocationRecord_ptr);
  void perform_invoke (InvocationRecord_ptr);
};
# 621 "../include/mico/poa_impl.h"
class POACurrent_impl : public PortableServer::Current
{
public:
  POACurrent_impl (CORBA::ORB_ptr);
  ~POACurrent_impl ();

  PortableServer::POA_ptr get_POA ();
  PortableServer::ObjectId * get_object_id ();


  CORBA::Boolean iscurrent ();
  CORBA::Object_ptr make_ref ();
  PortableServer::Servant get_serv ();
  POAObjectReference * get_por ();

  void set (PortableServer::POA_ptr, POAObjectReference *,
            PortableServer::Servant);
  void unset ();


private:
  CORBA::ORB_ptr orb;

  struct CurrentState {
    CurrentState ();
    CurrentState (PortableServer::POA_ptr,
                  POAObjectReference *,
                  PortableServer::Servant);
    CurrentState (const CurrentState &);
    ~CurrentState ();
    PortableServer::POA_ptr poa;
    POAObjectReference * por;
    PortableServer::Servant serv;
  };

  vector<CurrentState> CurrentStateStack;
};

}
# 34 "orb.cc" 2
# 1 "../include/mico/dynany_impl.h" 1
# 28 "../include/mico/dynany_impl.h"
class DynAny_impl : virtual public DynamicAny::DynAny {
protected:
    vector<DynamicAny::DynAny_var> _elements;
    CORBA::Long _index;
    CORBA::TypeCode_var _type;

    static DynamicAny::DynAnyFactory_ptr _factory();

    virtual void update_element (CORBA::Long idx);
public:
    DynAny_impl ();
    virtual ~DynAny_impl ();

    void assign (DynamicAny::DynAny_ptr dyn_any);
    DynamicAny::DynAny_ptr copy ();

    CORBA::TypeCode_ptr type ();
    virtual void destroy ();
    CORBA::Boolean equal (DynamicAny::DynAny_ptr dyn_any);

    void insert_boolean (CORBA::Boolean value);
    void insert_octet (CORBA::Octet value);
    void insert_char (CORBA::Char value);
    void insert_wchar (CORBA::WChar value);
    void insert_short (CORBA::Short value);
    void insert_ushort (CORBA::UShort value);
    void insert_long (CORBA::Long value);
    void insert_longlong (CORBA::LongLong value);
    void insert_ulong (CORBA::ULong value);
    void insert_ulonglong (CORBA::ULongLong value);
    void insert_float (CORBA::Float value);
    void insert_double (CORBA::Double value);
    void insert_longdouble (CORBA::LongDouble value);
    void insert_string (const char* value);
    void insert_wstring (const CORBA::WChar* value);
    void insert_reference (CORBA::Object_ptr value);
    void insert_typecode (CORBA::TypeCode_ptr value);
    void insert_any (const CORBA::Any &value);
    void insert_dyn_any (DynamicAny::DynAny_ptr value);
    void insert_val (CORBA::ValueBase *value);
    void insert_abstract (CORBA::AbstractBase * value);

    CORBA::Boolean get_boolean ();
    CORBA::Octet get_octet ();
    CORBA::Char get_char ();
    CORBA::WChar get_wchar ();
    CORBA::Short get_short ();
    CORBA::UShort get_ushort ();
    CORBA::Long get_long ();
    CORBA::LongLong get_longlong ();
    CORBA::ULong get_ulong ();
    CORBA::ULongLong get_ulonglong ();
    CORBA::Float get_float ();
    CORBA::Double get_double ();
    CORBA::LongDouble get_longdouble ();
    char* get_string ();
    CORBA::WChar* get_wstring ();
    CORBA::Object_ptr get_reference ();
    CORBA::TypeCode_ptr get_typecode ();
    CORBA::Any* get_any ();
    DynamicAny::DynAny_ptr get_dyn_any ();
    CORBA::ValueBase* get_val ();
    CORBA::AbstractBase* get_abstract ();

    DynamicAny::DynAny_ptr current_component ();
    CORBA::ULong component_count ();
    CORBA::Boolean next ();
    CORBA::Boolean seek (CORBA::Long index);
    void rewind ();

    virtual void from_any (const CORBA::Any& value) = 0;
    virtual CORBA::Any* to_any () = 0;
};


class DynBasic_impl : virtual public DynAny_impl,
                      virtual public DynamicAny::DynBasic {
private:
    CORBA::Any _value;

public:
    DynBasic_impl (CORBA::TypeCode_ptr);
    DynBasic_impl (const CORBA::Any &);
    virtual ~DynBasic_impl ();

    void destroy ();
    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();
};

class DynFixed_impl : virtual public DynAny_impl,
                      virtual public DynamicAny::DynFixed {
private:
    CORBA::Any _value;

public:
    DynFixed_impl (CORBA::TypeCode_ptr);
    DynFixed_impl (const CORBA::Any &);
    virtual ~DynFixed_impl ();

    void destroy ();
    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    char* get_value ();
    void set_value (const char *val);
};

class DynEnum_impl : virtual public DynAny_impl,
                     virtual public DynamicAny::DynEnum {
private:
    CORBA::Any _value;

public:
    DynEnum_impl (CORBA::TypeCode_ptr);
    DynEnum_impl (const CORBA::Any &);
    virtual ~DynEnum_impl ();

    void destroy ();
    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    char* get_as_string ();
    void set_as_string (const char* value);
    CORBA::ULong get_as_ulong ();
    void set_as_ulong (CORBA::ULong value);
};


class DynStruct_impl : virtual public DynAny_impl,
                       virtual public DynamicAny::DynStruct {
private:
    CORBA::Boolean _isexcept;
public:
    DynStruct_impl (CORBA::TypeCode_ptr);
    DynStruct_impl (const CORBA::Any &);
    virtual ~DynStruct_impl ();

    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    DynamicAny::FieldName current_member_name ();
    CORBA::TCKind current_member_kind ();
    DynamicAny::NameValuePairSeq* get_members ();
    void set_members (const DynamicAny::NameValuePairSeq& value);
    DynamicAny::NameDynAnyPairSeq* get_members_as_dyn_any ();
    void set_members_as_dyn_any (const DynamicAny::NameDynAnyPairSeq& value);
};


class DynUnion_impl : virtual public DynAny_impl,
                      virtual public DynamicAny::DynUnion {
private:
    virtual void update_element (CORBA::Long idx);
    CORBA::Long _member_idx;

    CORBA::Boolean has_default_member();
public:
    DynUnion_impl (CORBA::TypeCode_ptr);
    DynUnion_impl (const CORBA::Any &);
    virtual ~DynUnion_impl ();

    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();
    CORBA::ULong component_count ();

    DynamicAny::DynAny_ptr get_discriminator ();
    void set_discriminator (DynamicAny::DynAny_ptr d);
    void set_to_default_member ();
    void set_to_no_active_member ();
    CORBA::Boolean has_no_active_member ();
    CORBA::TCKind discriminator_kind ();
    DynamicAny::DynAny_ptr member ();
    DynamicAny::FieldName member_name ();
    CORBA::TCKind member_kind ();
};

class DynSequence_impl : virtual public DynAny_impl,
                         virtual public DynamicAny::DynSequence {
private:
    CORBA::ULong _length;
public:
    DynSequence_impl (CORBA::TypeCode_ptr);
    DynSequence_impl (const CORBA::Any &);
    virtual ~DynSequence_impl ();

    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    CORBA::ULong get_length ();
    void set_length (CORBA::ULong value);
    DynamicAny::AnySeq* get_elements ();
    void set_elements (const DynamicAny::AnySeq& value);
    DynamicAny::DynAnySeq* get_elements_as_dyn_any ();
    void set_elements_as_dyn_any (const DynamicAny::DynAnySeq& value);
};


class DynArray_impl : virtual public DynAny_impl,
                      virtual public DynamicAny::DynArray {
private:
    CORBA::ULong _length;
public:
    DynArray_impl (CORBA::TypeCode_ptr);
    DynArray_impl (const CORBA::Any &);
    virtual ~DynArray_impl ();

    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    DynamicAny::AnySeq* get_elements ();
    void set_elements (const DynamicAny::AnySeq& value);
    DynamicAny::DynAnySeq* get_elements_as_dyn_any ();
    void set_elements_as_dyn_any (const DynamicAny::DynAnySeq& value);
};

class DynValueCommon_impl : virtual public DynAny_impl,
                            virtual public DynamicAny::DynValueCommon {
protected:
  CORBA::Boolean _is_null;

public:
  DynValueCommon_impl ();
  CORBA::Boolean is_null ();
  void set_to_null ();
  void set_to_value ();
};

class DynValue_impl : virtual public DynValueCommon_impl,
                      virtual public DynamicAny::DynValue {
public:
    DynValue_impl (CORBA::TypeCode_ptr);
    DynValue_impl (const CORBA::Any &);
    virtual ~DynValue_impl ();

    void from_any (const CORBA::Any& value);
    CORBA::Any* to_any ();

    DynamicAny::FieldName current_member_name ();
    CORBA::TCKind current_member_kind ();
    DynamicAny::NameValuePairSeq* get_members ();
    void set_members (const DynamicAny::NameValuePairSeq& value);
    DynamicAny::NameDynAnyPairSeq* get_members_as_dyn_any ();
    void set_members_as_dyn_any (const DynamicAny::NameDynAnyPairSeq& value);
};

class DynValueBox_impl : virtual public DynValueCommon_impl,
                         virtual public DynamicAny::DynValueBox {
public:
  DynValueBox_impl (CORBA::TypeCode_ptr);
  DynValueBox_impl (const CORBA::Any &);
  virtual ~DynValueBox_impl ();

  void from_any (const CORBA::Any& value);
  CORBA::Any* to_any ();

  CORBA::Any * get_boxed_value ();
  void set_boxed_value (const CORBA::Any & boxed);
  DynamicAny::DynAny_ptr get_boxed_value_as_dyn_any ();
  void set_boxed_value_as_dyn_any (DynamicAny::DynAny_ptr boxed);
};

class DynAnyFactory_impl : virtual public DynamicAny::DynAnyFactory {
public:
    DynAnyFactory_impl ();
    virtual ~DynAnyFactory_impl ();

    DynamicAny::DynAny_ptr create_dyn_any (const CORBA::Any &value);
    DynamicAny::DynAny_ptr create_dyn_any_from_type_code (
        CORBA::TypeCode_ptr type);
};
# 35 "orb.cc" 2



# 1 "../include/mico/throw.h" 1
# 39 "orb.cc" 2
# 1 "/opt/gcc3/include/g++-v3/algorithm" 1 3
# 40 "orb.cc" 2




CORBA::ObjectAdapter::~ObjectAdapter ()
{
}

CORBA::ORBCallback::~ORBCallback ()
{
}





CORBA::ORBRequest::~ORBRequest ()
{
}





CORBA::ORBInvokeRec::ORBInvokeRec ()
{
    _have_result = 0;
    _type = RequestUnknown;
    _obj = 0;
    _target = 0;
    _principal = 0;
    _req = 0;
}

void
CORBA::ORBInvokeRec::init_invoke (ORB_ptr orb, MsgId id,
                                  Object_ptr o, ORBRequest *r,
                                  Principal_ptr pr,
                                  Boolean response,
                                  ORBCallback *callback, ObjectAdapter *oa)
{
    _have_result = 0;
    _type = RequestInvoke;

    _orb = orb;
    _myid = id;
    _obj = Object::_nil();
    _target = Object::_duplicate (o);
    _req = CORBA::ORBRequest::_duplicate (r);
    _principal = Principal::_duplicate (pr);
    _response_expected = response;
    _addr = 0;
    _adapter = oa;
    _cb = callback;
}

void
CORBA::ORBInvokeRec::init_bind (ORB_ptr orb, MsgId id, const char *repo,
                                const OctetSeq &tag, Address *a,
                                ORBCallback *callback, ObjectAdapter *oa)
{
    _have_result = 0;
    _type = RequestBind;

    _orb = orb;
    _myid = id;
    _obj = Object::_nil();
    _target = Object::_nil();
    _req = CORBA::ORBRequest::_nil();
    _principal = Principal::_nil();
    _response_expected = 1;
    _repoid = repo;
    _addr = a;
    _adapter = oa;
    _cb = callback;
    _objtag = tag;
}

void
CORBA::ORBInvokeRec::init_locate (ORB_ptr orb, MsgId id, Object_ptr o,
                                  ORBCallback *callback, ObjectAdapter *oa)
{
    _have_result = 0;
    _type = RequestLocate;

    _orb = orb;
    _myid = id;
    _obj = Object::_nil();
    _target = Object::_duplicate (o);
    _req = CORBA::ORBRequest::_nil();
    _principal = Principal::_nil();
    _response_expected = 1;
    _addr = 0;
    _adapter = oa;
    _cb = callback;
}

CORBA::ORBInvokeRec::~ORBInvokeRec ()
{

    CORBA::release (_obj);
    CORBA::release (_target);
    CORBA::release (_principal);
    CORBA::release (_req);
}

void
CORBA::ORBInvokeRec::free ()
{
    CORBA::release (_obj);
    CORBA::release (_target);
    CORBA::release (_principal);
    CORBA::release (_req);

    _have_result = 0;
    _type = RequestUnknown;
    _obj = 0;
    _target = 0;
    _principal = 0;
    _req = 0;
}

void
CORBA::ORBInvokeRec::redo ()
{
    ((void) ((_adapter) ? 0 : (__assert_fail ("_adapter", "orb.cc", 165, __PRETTY_FUNCTION__), 0)));
    ((void) ((!_have_result) ? 0 : (__assert_fail ("!_have_result", "orb.cc", 166, __PRETTY_FUNCTION__), 0)));

    switch (_type) {
    case RequestInvoke:

        _target->_unforward();
        _adapter->invoke (_myid, _target, _req, _principal,
                          _response_expected);
        break;

    case RequestLocate:
        _adapter->locate (_myid, _target);
        break;

    case RequestBind:
        _adapter->bind (_myid, _repoid.c_str(), _objtag, _addr);
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "orb.cc", 185, __PRETTY_FUNCTION__), 0)));
    }
}

void
CORBA::ORBInvokeRec::set_answer_invoke (InvokeStatus state,
                                        Object_ptr o,
                                        ORBRequest *r,
                                        CORBA::GIOP::AddressingDisposition ad)
{
    ((void) ((_type == RequestInvoke) ? 0 : (__assert_fail ("_type == RequestInvoke", "orb.cc", 195, __PRETTY_FUNCTION__), 0)));
    ((void) ((!_have_result) ? 0 : (__assert_fail ("!_have_result", "orb.cc", 196, __PRETTY_FUNCTION__), 0)));

    _have_result = 1;
    _invoke_stat = state;

    switch (state) {
    case InvokeOk:
    case InvokeUsrEx:
    case InvokeSysEx:
        if (!_req->copy_out_args (r)) {
            CORBA::MARSHAL ex;
            _req->set_out_args (&ex);
            _invoke_stat = InvokeSysEx;
        }
        break;

    case InvokeForward:
        _obj = Object::_duplicate (o);
        break;

    case InvokeAddrDisp:
        _ad = ad;
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "orb.cc", 221, __PRETTY_FUNCTION__), 0)));
    }
}

void
CORBA::ORBInvokeRec::set_answer_bind (LocateStatus state, Object_ptr o)
{
    ((void) ((_type == RequestBind) ? 0 : (__assert_fail ("_type == RequestBind", "orb.cc", 228, __PRETTY_FUNCTION__), 0)));
    ((void) ((!_have_result) ? 0 : (__assert_fail ("!_have_result", "orb.cc", 229, __PRETTY_FUNCTION__), 0)));

    _have_result = 1;
    _locate_stat = state;

    switch (state) {
    case LocateForward:
    case LocateUnknown:
        break;

    case LocateHere:
        _obj = Object::_duplicate (o);
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "orb.cc", 244, __PRETTY_FUNCTION__), 0)));
    }
}

void
CORBA::ORBInvokeRec::set_answer_locate (LocateStatus state, Object_ptr o,
                                        CORBA::GIOP::AddressingDisposition ad)
{
    ((void) ((_type == RequestLocate) ? 0 : (__assert_fail ("_type == RequestLocate", "orb.cc", 252, __PRETTY_FUNCTION__), 0)));
    ((void) ((!_have_result) ? 0 : (__assert_fail ("!_have_result", "orb.cc", 253, __PRETTY_FUNCTION__), 0)));

    _have_result = 1;
    _locate_stat = state;

    switch (state) {
    case LocateHere:
    case LocateUnknown:
        break;

    case LocateForward:
        _obj = Object::_duplicate (o);
        break;

    case LocateAddrDisp:
        _ad = ad;
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "orb.cc", 272, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
CORBA::ORBInvokeRec::get_answer_invoke (InvokeStatus &state, Object_ptr &o,
                                        ORBRequest *&r,
                                        CORBA::GIOP::AddressingDisposition &ad)
{
    ((void) ((_type == RequestInvoke) ? 0 : (__assert_fail ("_type == RequestInvoke", "orb.cc", 281, __PRETTY_FUNCTION__), 0)));
    if (!_have_result)
        return 0;

    o = _obj;
    state = _invoke_stat;
    r = _req;
    ad = _ad;
    return 1;
}

CORBA::Boolean
CORBA::ORBInvokeRec::get_answer_bind (LocateStatus &state, Object_ptr &o)
{
    ((void) ((_type == RequestBind) ? 0 : (__assert_fail ("_type == RequestBind", "orb.cc", 295, __PRETTY_FUNCTION__), 0)));
    if (!_have_result)
        return 0;

    o = _obj;
    state = _locate_stat;
    return 1;
}

CORBA::Boolean
CORBA::ORBInvokeRec::get_answer_locate (LocateStatus &state, Object_ptr &o,
                                        CORBA::GIOP::AddressingDisposition &ad)
{
    ((void) ((_type == RequestLocate) ? 0 : (__assert_fail ("_type == RequestLocate", "orb.cc", 308, __PRETTY_FUNCTION__), 0)));
    if (!_have_result)
        return 0;

    o = _obj;
    state = _locate_stat;
    ad = _ad;
    return 1;
}





static CORBA::ORB_ptr orb_instance = CORBA::ORB::_nil();
static MICO::IIOPProxy *iiop_proxy_instance = 0;

CORBA::ORB::ORB (int &argc, char **argv, const char *rcfile)
{
    _disp = new MICO::SelectDispatcher ();
    _theid = 1;
    _currentid = 0;
    _rcfile = rcfile;
    _wait_for_completion = 0;
    _is_running = 0;
    _is_stopped = 1;
    _is_shutdown = 0;

    _cache_used = 0;
    _cache_rec = new ORBInvokeRec;

    _tmpl = new IOR;
}

CORBA::ORB::~ORB ()
{
    delete _cache_rec;
    delete _disp;
    delete _tmpl;

    map<MsgId, ORBInvokeRec *, less<MsgId> >::iterator i;
    for (i = _invokes.begin(); i != _invokes.end(); ++i)
        delete (*i).second;
}
# 360 "orb.cc"
CORBA::Object_ptr
CORBA::ORB::iioploc_to_object (const char * str)
{
  string iioploc (str);
  size_t pos = iioploc.find ("//");

  if (strncmp (str, "iioploc:", 8) != 0 || pos != 8) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  string addresses;
  Octet * key;
  ULong len;

  size_t pos2 = iioploc.find ('/', pos+2);

  if (pos2 != (size_t) -1) {
    addresses = iioploc.substr (pos+2, pos2-pos-2);
    key = mico_url_decode (iioploc.substr(pos2+1).c_str(), len);
  }
  else {
    addresses = iioploc.substr (pos+2);
    len = 0;
    key = __null;
  }

  if (addresses.length() == 0) {
    addresses = MICO::InetAddress::hostname();
  }

  IOR * ior = new IOR;
  ULong profiles=0;

  while (addresses.length()) {
    string version, host, port;

    if ((pos = addresses.find(',')) == (size_t) -1) {
      host = addresses;
      addresses = "";
    }
    else {
      host = addresses.substr (0, pos);
      addresses = addresses.substr (pos+1);
    }

    if ((pos = host.find ('@')) != (size_t) -1) {
      version = host.substr (0, pos);
      host = host.substr (pos+1);
    }
    else {
      version = "1.0";
    }

    if ((pos = host.find (':')) != (size_t) -1) {
      port = host.substr (pos+1);
      host = host.substr (0, pos);
    }
    else {
      port = "9999";
    }

    if (host.length() == 0) {
      host = MICO::InetAddress::hostname();
    }

    if ((pos = version.find ('.')) == (size_t) -1) {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
    }

    UShort portno = atoi (port.c_str());
    UShort major, minor;

    major = (UShort) atoi (version.c_str());
    minor = (UShort) atoi (version.c_str() + pos + 1);



    MICO::InetAddress * addr = new MICO::InetAddress (host.c_str(), portno);

    if (!addr->valid()) {
      delete addr;
      mico_throw (BAD_PARAM());
    }

    MICO::IIOPProfile * prof = new MICO::IIOPProfile (key, len, *addr,
                                                      MultiComponent(),
                                                      major*256 +minor);

    ior->add_profile (prof);
    delete addr;
    profiles++;
  }

  CORBA::string_free ((char *) key);
  return ior_to_object (ior);
}
# 464 "orb.cc"
CORBA::Object_ptr
CORBA::ORB::iiopname_to_object (const char * str)
{
  string iiopname (str);
  size_t pos = iiopname.find ("//");

  if (strncmp (str, "iiopname:", 9) != 0 || pos != 9) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  string addresses;
  string key;

  size_t pos2 = iiopname.find ('/', pos+2);

  if (pos2 != (size_t) -1) {
    addresses = iiopname.substr (pos+2, pos2-pos-2);
    key = iiopname.substr (pos2+1);
  }
  else {
    addresses = iiopname.substr (pos+2);
  }

  string nsloc = "iioploc://";
  nsloc += addresses;
  nsloc += '/';
  nsloc += "NameService";

  Object_var nsobj = string_to_object (nsloc.c_str());

  if (CORBA::is_nil (nsobj)) {
    return Object::_nil ();
  }





  if (key.length() == 0) {
    return Object::_duplicate (nsobj);
  }






  Request_var req = nsobj->_request ("resolve_str");
  *(req->arguments()->add(ARG_IN)->value()) <<= key.c_str();
  req->set_return_type (CORBA::_tc_Object);
  try { req->invoke (); } catch (...) {};

  if (req->env()->exception()) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
  }

  Object_var res;
  if (!(req->return_value() >>= CORBA::Any::to_object (res))) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 10, CORBA::COMPLETED_NO));
  }

  IOR * ior = new IOR (*res->_ior());
  return ior_to_object (ior);
}
# 544 "orb.cc"
CORBA::Object_ptr
CORBA::ORB::corbaloc_to_object (const char * str)
{
  if (strncmp (str, "corbaloc:", 9) != 0) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  string corbaloc (str);
  size_t pos = corbaloc.find ('/');

  string obj_addr_list;
  string url_encoded_key_string;
  Octet * key_string;
  ULong key_length;

  if (pos == (size_t) -1) {
    obj_addr_list = corbaloc.substr (9);
    key_string = __null;
    key_length = 0;
  }
  else {
    obj_addr_list = corbaloc.substr (9, pos-9);
    url_encoded_key_string = corbaloc.substr (pos+1);
    key_string = mico_url_decode (url_encoded_key_string.c_str(), key_length);
  }





  if (strncmp (obj_addr_list.c_str(), "rir:", 4) == 0) {




    if (obj_addr_list.find (',') != (size_t) -1) {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
    }

    CORBA::String_var rir = (char *) key_string;





    if (key_length == 0) {
      rir = CORBA::string_dup ("NameService");
    }





    return resolve_initial_references (rir.in());
  }





  IOR * ior = new IOR;
  ULong profiles = 0;

  while (obj_addr_list.length() > 0) {
    string obj_addr;

    if ((pos = obj_addr_list.find (',')) == (size_t) -1) {
      obj_addr = obj_addr_list;
      obj_addr_list = "";
    }
    else {
      obj_addr = obj_addr_list.substr (0, pos);
      obj_addr_list = obj_addr_list.substr (pos+1);
    }





    string iiop_addr;

    if (strncmp (obj_addr.c_str(), ":", 1) == 0) {
      iiop_addr = obj_addr.substr (1);
    }
    else if (strncmp (obj_addr.c_str(), "iiop:", 5) == 0) {
      iiop_addr = obj_addr.substr (5);
    }
    else {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
    }

    string version, host, port;





    if ((pos = iiop_addr.find ('@')) != (size_t) -1) {
      version = iiop_addr.substr (0, pos);
      iiop_addr = iiop_addr.substr (pos+1);
    }
    else {
      version = "1.0";
    }

    if ((pos = iiop_addr.find (':')) != (size_t) -1) {
      port = iiop_addr.substr (pos+1);
      iiop_addr = iiop_addr.substr (0, pos);
    }
    else {
      port = "2089";
    }

    host = iiop_addr;





    if ((pos = version.find ('.')) == (size_t) -1) {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
    }

    UShort portno = atoi (port.c_str());
    UShort major, minor;

    major = (UShort) atoi (version.c_str());
    minor = (UShort) atoi (version.c_str() + pos + 1);





    MICO::InetAddress * addr = new MICO::InetAddress (host.c_str(), portno);

    if (!addr->valid()) {
      CORBA::string_free ((char *) key_string);
      delete addr;
      delete ior;
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
    }

    MICO::IIOPProfile * prof = new MICO::IIOPProfile (key_string, key_length,
                                                      *addr, MultiComponent(),
                                                      major*256 +minor);

    ior->add_profile (prof);
    delete addr;
    profiles++;
  }

  CORBA::string_free ((char *) key_string);
  return ior_to_object (ior);
}







CORBA::Object_ptr
CORBA::ORB::corbaname_to_object (const char * str)
{
  if (strncmp (str, "corbaname:", 10) != 0) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  string corbaname (str);
  size_t pos = corbaname.find ('#');

  string corbaloc_obj;
  string url_name;






  if (pos == (size_t) -1) {
    corbaloc_obj = corbaname.substr (10);
  }
  else {
    corbaloc_obj = corbaname.substr (10, pos-10);
    url_name = corbaname.substr (pos+1);
  }

  string corbaloc = "corbaloc:";
  corbaloc += corbaloc_obj;






  if (corbaloc_obj.find ('/') == (size_t) -1) {
    corbaloc += "/NameService";
  }






  CORBA::Object_var ncobj = string_to_object (corbaloc.c_str());





  if (url_name.length() == 0) {
    return Object::_duplicate (ncobj);
  }






  CORBA::ULong string_length;
  CORBA::String_var string_name =
    (char *) mico_url_decode (url_name.c_str(), string_length);






  Request_var req = ncobj->_request ("resolve_str");
  *(req->arguments()->add(ARG_IN)->value()) <<= string_name.in();
  req->set_return_type (CORBA::_tc_Object);
  try { req->invoke (); } catch (...) {};

  if (req->env()->exception()) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 10, CORBA::COMPLETED_NO));
  }

  Object_ptr res;
  if (!(req->return_value() >>= CORBA::Any::to_object (res))) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 10, CORBA::COMPLETED_NO));
  }





  return res;
}





CORBA::Object_ptr
CORBA::ORB::file_to_object (const char * str)
{
  string filename (str);
  size_t pos = filename.find ("//");

  if (strncmp (str, "file:", 5) != 0 || pos != 5) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  size_t pos2 = filename.find ('/', pos+2);
  if (pos2 == (size_t) -1) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  string host = filename.substr (pos+2, pos2-pos-2);
  filename = filename.substr (pos2);
# 828 "orb.cc"
  if (host.length() > 0 &&
      strcmp (host.c_str(), "localhost") != 0 &&
      strcmp (host.c_str(), "127.0.0.1") != 0) {
    MICO::InetAddress i1 (host.c_str(), 0);
    MICO::InetAddress i2 ("localhost", 0);
    if (!i1.valid() || !i2.valid() || i1.compare (i2) != 0) {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
    }
  }

  CORBA::ULong len;
  CORBA::String_var fn =
    (char *) mico_url_decode (filename.c_str(), len);
  string ntfn (fn.in(), len);
# 854 "orb.cc"
  ifstream in (ntfn.c_str());
  string data;
  char buf[257];
  int count;

  if (!in.good()) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
  }

  while (in.good() && !in.eof()) {
    count = in.read (buf, 256).gcount();
    buf[count] = '\0';
    data += buf;
  }

  while (data.length() &&
         (data[data.length()-1] == '\r' || data[data.length()-1] == '\n')) {
    data.resize (data.length()-1);
  }

  return string_to_object (data.c_str());
}





CORBA::Object_ptr
CORBA::ORB::http_to_object (const char * str)
{
  string url (str);
  size_t pos = url.find ("//");
  string host, port, abs_path;

  if (pos != 5) {
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9, CORBA::COMPLETED_NO));
  }

  size_t pos2 = url.find ('/', pos+2);

  if (pos2 != (size_t) -1) {
    abs_path = url.substr (pos2);
    host = url.substr (pos+2, pos2-pos-2);
  }
  else {
    abs_path = "/";
    host = url;
  }

  if ((pos = host.find (':')) != (size_t) -1) {
    port = host.substr (pos+1);
    host = host.substr (0, pos-1);
  }
  else {
    port = "80";
  }

  UShort portno = atoi (port.c_str());

  MICO::InetAddress * addr = new MICO::InetAddress (host.c_str(), portno);

  if (!addr->valid()) {
    delete addr;
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
  }

  CORBA::Transport * trans = addr->make_transport ();

  if (!trans || trans->bad() || !trans->connect(addr)) {
    delete trans;
    delete addr;
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 8, CORBA::COMPLETED_NO));
  }

  delete addr;





  if (trans->write ("GET ", 4) != 4 ||
      trans->write ((void *) abs_path.c_str(),
                    abs_path.length()) != abs_path.length() ||
      trans->write ("\r\n\r\n", 4) != 4) {
    delete trans;
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 10, CORBA::COMPLETED_NO));
  }





  string data;
  char buf[257];

  while (!trans->eof() && !trans->bad()) {
    CORBA::Long got = trans->read (buf, 256);
    if (got > 0) {
      buf[got] = '\0';
      data += buf;
    }
  }

  if (trans->bad()) {
    delete trans;
    mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 10, CORBA::COMPLETED_NO));
  }

  delete trans;

  while (data.length() &&
         (data[data.length()-1] == '\r' || data[data.length()-1] == '\n')) {
    data.resize (data.length()-1);
  }




  for (int i = data.length()-1; i >= 0; --i) {
      if (data[i] == '\r' || data[i] == '\n') {
          data = data.substr (i+1);
          break;
      }
  }

  return string_to_object (data.c_str());
}

char *
CORBA::ORB::object_to_string (Object_ptr obj)
{
    (this)->_check ();

    if (CORBA::is_nil (obj)) {
        CORBA::IOR ior;
        return CORBA::string_dup (ior.stringify().c_str());
    }

    (obj)->_check (CORBA::OBJECT_NOT_EXIST());

    if (!obj->_ior())

        mico_throw (MARSHAL());
    return CORBA::string_dup (obj->_ior()->stringify().c_str());
}

CORBA::Object_ptr
CORBA::ORB::string_to_object (const char *str)
{
    (this)->_check ();

    if (!str)
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 7, CORBA::COMPLETED_NO));

    if (strncmp (str, "IOR:", 4) == 0) {
        IOR *ior = new IOR;
        if (!ior->from_string (str)) {
            delete ior;
            mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 9,
                                          CORBA::COMPLETED_NO));
        }
        return ior_to_object (ior);
    } else if (strncmp (str, "corbaname:", 10) == 0) {
      return corbaname_to_object (str);
    } else if (strncmp (str, "corbaloc:", 9) == 0) {
      return corbaloc_to_object (str);
    } else if (strncmp (str, "iioploc:", 8) == 0) {
      if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
        MICO::Logger::Stream (MICO::Logger::Warning)
          << "Warning: use of old iioploc format" << endl;
      }
      return iioploc_to_object (str);
    } else if (strncmp (str, "iiopname:", 9) == 0) {
      if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
        MICO::Logger::Stream (MICO::Logger::Warning)
          << "Warning: use of old iiopname format" << endl;
      }
      return iiopname_to_object (str);
    } else if (strncmp (str, "file:", 5) == 0) {
      return file_to_object (str);
    } else if (strncmp (str, "http:", 5) == 0) {
      return http_to_object (str);
    } else {
      mico_throw (CORBA::BAD_PARAM (CORBA::OMGVMCID | 7,
                                    CORBA::COMPLETED_NO));

      return Object::_nil();
    }
}

CORBA::Object_ptr
CORBA::ORB::ior_to_object (IOR *ior)
{
    if (!ior->profile()) {
        delete ior;
        return CORBA::Object::_nil();
    }

    Object_var obj = new Object (ior);
    obj->_setup_domains (CORBA::Object::_nil());

    ObjectAdapter *oa = get_oa (obj);
    if (oa && oa->is_local ()) {
        CORBA::Object_var skel = oa->skeleton (obj);
        if (!CORBA::is_nil (skel)) {
            return Object::_duplicate (skel);
        }
    }
    return Object::_duplicate (obj);
}

CORBA::Boolean
CORBA::ORB::is_impl (Object_ptr obj)
{
    if (CORBA::is_nil (obj)) {
      return 0;
    }
    ObjectAdapter *oa = get_oa (obj);
    if (!oa || !oa->is_local()) {
      return 0;
    }
    CORBA::Object_var skel = oa->skeleton (obj);
    return skel.in() == obj;
}

const char *
CORBA::ORB::rcfile()
{
    return _rcfile.c_str();
}

char *
CORBA::ORB::tag_to_string (const ObjectTag &oid)
{
    string s;

    for (CORBA::ULong i = 0; i < oid.length(); ++i) {
        ((void) (((CORBA::Octet)oid[i]) ? 0 : (__assert_fail ("(CORBA::Octet)oid[i]", "orb.cc", 1091, __PRETTY_FUNCTION__), 0)));
        s += (char)(CORBA::Octet)oid[i];
    }
    return CORBA::string_dup (s.c_str());
}

CORBA::ORB::ObjectTag *
CORBA::ORB::string_to_tag (const char *s)
{
    CORBA::ULong len = strlen (s);

    CORBA::ORB::ObjectTag *oid = new CORBA::ORB::ObjectTag;
    oid->length (len);

    for (CORBA::ULong i = 0; i < len; ++i) {
        (*oid)[i] = (CORBA::Octet) s[i];
    }
    return oid;
}

void
CORBA::ORB::create_list (Long len, NVList_out res)
{
    if (len < 0)
        mico_throw (CORBA::BAD_PARAM());

    res = new NVList (len);
}

void
CORBA::ORB::create_operation_list (OperationDef_ptr op, NVList_out res)
{
    res = new NVList (0);
    ParDescriptionSeq_var params = op->params();
    for (CORBA::ULong i = 0; i < params->length(); ++i) {
        switch (params[i].mode) {
        case PARAM_IN:
            res->add(ARG_IN)->value()->set_type (params[i].type);
            break;
        case PARAM_OUT:
            res->add(ARG_OUT)->value()->set_type (params[i].type);
            break;
        case PARAM_INOUT:
            res->add(ARG_INOUT)->value()->set_type (params[i].type);
            break;
        default:
            ((void) ((0) ? 0 : (__assert_fail ("0", "orb.cc", 1137, __PRETTY_FUNCTION__), 0)));
        }
    }
}

void
CORBA::ORB::create_named_value (NamedValue_out res)
{
    res = new NamedValue;
}

void
CORBA::ORB::create_exception_list (ExceptionList_out res)
{
    res = new ExceptionList;
}

void
CORBA::ORB::create_context_list (ContextList_out res)
{
    res = new ContextList;
}

void
CORBA::ORB::create_environment (Environment_out res)
{
    res = new Environment;
}

void
CORBA::ORB::get_default_context (Context_out res)
{
    res = new Context ("");
}

void
CORBA::ORB::get_default_domain_manager (DomainManager_out dm)
{
    (this)->_check ();

    if (CORBA::is_nil (_def_manager)) {
        _def_manager = new MICO::DomainManager_impl;


        MICOPolicy::TransportPrefPolicy::ProfileTagSeq prefs;
        prefs.length (6);

        prefs[0] = CORBA::IORProfile::TAG_INTERNET_IOP;
        prefs[1] = CORBA::IORProfile::TAG_UNIX_IOP;
        prefs[2] = CORBA::IORProfile::TAG_UDP_IOP;
        prefs[3] = CORBA::IORProfile::TAG_SSL_INTERNET_IOP;
        prefs[4] = CORBA::IORProfile::TAG_SSL_UNIX_IOP;
        prefs[5] = CORBA::IORProfile::TAG_SSL_UDP_IOP;

        MICOPolicy::TransportPrefPolicy_var tpp =
            new MICO::TransportPrefPolicy_impl (prefs);

        _def_manager->set_domain_policy (tpp);
    }
    dm = CORBA::DomainManager::_duplicate (_def_manager);
}

CORBA::Boolean
CORBA::ORB::get_service_information (
    CORBA::ServiceType service_type,
    CORBA::ServiceInformation_out service_information)
{
    return 0;
}

void
CORBA::ORB::send_multiple_requests_oneway (const RequestSeq &req)
{
    for (CORBA::ULong i = 0; i < req.length(); ++i) {
        req[i]->send_oneway ();
    }
}

void
CORBA::ORB::send_multiple_requests_deferred (const RequestSeq &req)
{
    for (CORBA::ULong i = 0; i < req.length(); ++i) {
        req[i]->send_deferred ();
    }
}

CORBA::Boolean
CORBA::ORB::poll_next_response ()
{
    (this)->_check ();

    ORBInvokeRec *rec;
    ORBRequest *orbreq;

    if (_cache_used) {
      if (_cache_rec->request_type() == RequestInvoke &&
          _cache_rec->completed() &&
          !strcmp (_cache_rec->request()->type(), "local")) {
        return 1;
      }
    }

    for (InvokeMap::iterator i = _invokes.begin(); i != _invokes.end(); ++i) {
        rec = (*i).second;
        orbreq = rec->request ();
        if (rec->request_type() == RequestInvoke &&
            rec->completed() &&
            !strcmp (orbreq->type(), "local")) {

            return 1;
        }
    }
    return 0;
}

void
CORBA::ORB::get_next_response (Request_out req)
{
    (this)->_check ();

    ORBInvokeRec *rec;
    ORBRequest *orbreq;

    if (_cache_used) {
      if (_cache_rec->request_type() == RequestInvoke &&
          _cache_rec->completed() &&
          !strcmp (_cache_rec->request()->type(), "local")) {
        req = Request::_duplicate (((MICO::LocalRequest *)(_cache_rec->request()))->request());
        return;
      }
    }

    for (InvokeMap::iterator i = _invokes.begin(); i != _invokes.end(); ++i) {
        rec = (*i).second;
        orbreq = rec->request ();
        if (rec->request_type() == RequestInvoke &&
            rec->completed() &&
            !strcmp (orbreq->type(), "local")) {

            req = Request::_duplicate (
                ((MICO::LocalRequest *)orbreq)->request());
            return;
        }
    }
    req = Request::_nil();
}

void
CORBA::ORB::do_shutdown ()
{
    if (!_is_shutdown) {
        _is_shutdown = 1;

        if (_wait_for_completion)
            _shutting_down_adapters = _adapters;


        OAVec adapters_copy = _adapters;
        for (ULong i = 0; i < adapters_copy.size(); ++i) {
            adapters_copy[i]->shutdown (_wait_for_completion);
        }
        if (_wait_for_completion) {
            while (_shutting_down_adapters.size() > 0)
                _disp->run (0);
        }
        _is_shutdown = 2;
    }
}

CORBA::Boolean
CORBA::ORB::work_pending ()
{
    if (_is_shutdown > 1)
        mico_throw (CORBA::BAD_INV_ORDER (4, CORBA::COMPLETED_NO));


    return !_disp->idle();
}

void
CORBA::ORB::perform_work ()
{
    if (_is_shutdown > 1)
        mico_throw (CORBA::BAD_INV_ORDER (4, CORBA::COMPLETED_NO));

    _disp->run (0);
}

void
CORBA::ORB::run ()
{
    ((void) ((!_is_running) ? 0 : (__assert_fail ("!_is_running", "orb.cc", 1328, __PRETTY_FUNCTION__), 0)));
    _is_running = 1;
    _is_stopped = 0;
    while (!_is_stopped)
        _disp->run (0);

    do_shutdown ();
}

void
CORBA::ORB::answer_shutdown (ObjectAdapter *oa)
{
    for (ULong i = 0; i < _shutting_down_adapters.size(); ++i) {
        if (_shutting_down_adapters[i] == oa) {
            _shutting_down_adapters.erase (_shutting_down_adapters.begin()+i);
            break;
        }
    }
}

void
CORBA::ORB::shutdown (Boolean wait)
{
    _wait_for_completion = wait;
    _is_stopped = 1;



    if (!_is_running)
        do_shutdown();
}

void
CORBA::ORB::destroy ()
{


}

CORBA::BOA_ptr
CORBA::ORB::BOA_init (int &argc, char **argv, const char *_id)
{
    string id = _id;

    MICOGetOpt::OptMap opts;
    opts["-OAId"] = "arg-expected";

    MICOGetOpt opt_parser (opts);
    if (!opt_parser.parse (rcfile(), 1))
        mico_throw (CORBA::INITIALIZE());
    if (!opt_parser.parse (argc, argv, 1))
        mico_throw (CORBA::INITIALIZE());
    const MICOGetOpt::OptVec &o = opt_parser.opts();

    for (MICOGetOpt::OptVec::const_iterator i0 = o.begin(); i0 != o.end(); ++i0) {
        string arg = (*i0).first;
        string val = (*i0).second;
        if (arg == "-OAId") {
            if (id.length() == 0)
                id = val;
        }
    }

    for (ULong i1 = 0; i1 < _adapters.size(); ++i1) {
        if (!strcmp (id.c_str(), _adapters[i1]->get_oaid()))
            return CORBA::BOA::_duplicate ((MICO::BOAImpl *)_adapters[i1]);
    }
    if (id.length() > 0 && strcmp ("mico-local-boa", id.c_str())) {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: unknown OA id " << id << " in BOA_init" << endl;
      }
      mico_throw (CORBA::INITIALIZE());
    }

    CORBA::BOA_ptr boa = new MICO::BOAImpl (this, argc, argv);
    return CORBA::BOA::_duplicate (boa);
}

CORBA::BOA_ptr
CORBA::ORB::BOA_instance (const char *id, Boolean create)
{
    for (ULong i = 0; i < _adapters.size(); ++i) {
        if (!strcmp (id, _adapters[i]->get_oaid()))
            return CORBA::BOA::_duplicate ((MICO::BOAImpl *)_adapters[i]);
    }
    if (!create)
        return BOA::_nil();
    int argc = 0;
    char *argv = 0;
    return BOA_init (argc, &argv, id);
}

CORBA::ORB::ObjectIdList *
CORBA::ORB::list_initial_services ()
{
    (this)->_check ();

    ObjectIdList_ptr idlist = new ObjectIdList;
    idlist->length (_init_refs.size());

    int j;
    InitialRefMap::iterator i;
    for (j = 0, i = _init_refs.begin(); i != _init_refs.end(); ++i, ++j)
        (*idlist)[j] = (*i).first.c_str();

    if (!_init_refs.count ("RootPOA")) {
        idlist->length (j+1);
        (*idlist)[j++] = (const char *)"RootPOA";
    }
    if (!_init_refs.count ("POACurrent")) {
        idlist->length (j+1);
        (*idlist)[j++] = (const char *)"POACurrent";
    }
    if (!_init_refs.count ("DynAnyFactory")) {
        idlist->length (j+1);
        (*idlist)[j++] = (const char *)"DynAnyFactory";
    }
    if (!_init_refs.count ("PrincipalCurrent")) {
        idlist->length (j+1);
        (*idlist)[j++] = (const char *)"PrincipalCurrent";
    }
    return idlist;
}

CORBA::Object_ptr
CORBA::ORB::resolve_initial_references (const char *id)
{
    (this)->_check ();

    InitialRefMap::iterator i = _init_refs.find (id);

    if (i == _init_refs.end()) {
        if (_default_init_ref.length() > 0) {
          string loc = _default_init_ref;
          loc += '/';
          loc += id;
          CORBA::Object_ptr res = string_to_object (loc.c_str());
          if (!CORBA::is_nil (res)) {
            return res;
          }
        }

        if (!strcmp (id, "RootPOA")) {
          PortableServer::POA_var rootpoa = new MICOPOA::POA_impl (this);
        } else if (!strcmp (id, "POACurrent")) {

          PortableServer::POA_var rootpoa = new MICOPOA::POA_impl (this);
        } else if (!strcmp (id, "DynAnyFactory")) {
          _init_refs[id] = new DynAnyFactory_impl;
        } else if (!strcmp (id, "PrincipalCurrent")) {
          _init_refs[id] = new PrincipalCurrent_impl;
        } else {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: unknown id " << id
              << " in resolve_initial_references" << endl;
          }
          mico_throw (CORBA::ORB::InvalidName());
        }
        i = _init_refs.find (id);
    }
    return Object::_duplicate ((*i).second);
}

CORBA::Boolean
CORBA::ORB::set_initial_reference (const char *id, Object_ptr obj)
{
    _init_refs[id] = CORBA::Object::_duplicate (obj);
    return 1;
}

CORBA::Boolean
CORBA::ORB::set_default_initial_reference (const char * url)
{
  _default_init_ref = url;
  return 1;
}

CORBA::TypeCode_ptr
CORBA::ORB::create_struct_tc (const char *rep_id,
                              const char *name,
                              const StructMemberSeq &members)
{
    return TypeCode::create_struct_tc (rep_id, name, members);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_union_tc (const char *rep_id,
                             const char *name,
                             TypeCode_ptr disc_type,
                             const UnionMemberSeq &members)
{
    return TypeCode::create_union_tc (rep_id, name, disc_type, members);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_enum_tc (const char *rep_id,
                            const char *name,
                            const EnumMemberSeq &members)
{
    return TypeCode::create_enum_tc (rep_id, name, members);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_exception_tc (const char *rep_id,
                                 const char *name,
                                 const StructMemberSeq &mems)
{
    return TypeCode::create_exception_tc (rep_id, name, mems);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_alias_tc (const char *rep_id,
                             const char *name,
                             TypeCode_ptr orig_type)
{
    return TypeCode::create_alias_tc (rep_id, name, orig_type);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_interface_tc (const char *rep_id, const char *name)
{
    return TypeCode::create_interface_tc (rep_id, name);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_string_tc (ULong bound)
{
    return TypeCode::create_string_tc (bound);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_wstring_tc (ULong bound)
{
    return TypeCode::create_wstring_tc (bound);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_fixed_tc (UShort digits, Short scale)
{
    return TypeCode::create_fixed_tc (digits, scale);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_sequence_tc (ULong bound, TypeCode_ptr el_type)
{
    return TypeCode::create_sequence_tc (bound, el_type);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_recursive_sequence_tc (ULong bound, ULong offset)
{
    return TypeCode::create_recursive_sequence_tc (bound, offset);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_array_tc (ULong length, TypeCode_ptr el_type)
{
    return TypeCode::create_array_tc (length, el_type);
}


CORBA::TypeCode_ptr
CORBA::ORB::create_value_tc (const char *rep_id, const char *name,
                             ValueModifier mod,
                             TypeCode_ptr concrete_base,
                             const ValueMemberSeq &members)
{
    return TypeCode::create_value_tc (rep_id, name, mod,
                                      concrete_base, members);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_value_box_tc (const char *rep_id,
                                 const char *name,
                                 TypeCode_ptr boxed_type)
{
    return TypeCode::create_value_box_tc (rep_id, name, boxed_type);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_native_tc (const char *rep_id,
                              const char *name)
{
    return TypeCode::create_native_tc (rep_id, name);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_recursive_tc (const char *rep_id)
{
    return TypeCode::create_recursive_tc (rep_id);
}

CORBA::TypeCode_ptr
CORBA::ORB::create_abstract_interface_tc (const char *rep_id,
                                          const char *name)
{
    return TypeCode::create_abstract_interface_tc (rep_id, name);
}

CORBA::ORB::MsgId
CORBA::ORB::new_msgid ()
{
    if (_theid == 0)
        _theid = 1;
    return _theid++;
}

CORBA::ORBInvokeRec *
CORBA::ORB::create_invoke ()
{
    if (!_cache_used) {
        _cache_used = 1;
        return _cache_rec;
    }
    return new ORBInvokeRec;
}

void
CORBA::ORB::add_invoke (ORBInvokeRec *rec)
{
    if (rec == _cache_rec)
        return;

    _invokes[rec->id()] = rec;
}

CORBA::ORBInvokeRec *
CORBA::ORB::get_invoke (MsgId id)
{
    if (_cache_used && _cache_rec->id() == id)
        return _cache_rec;

    map<MsgId, ORBInvokeRec *, less<MsgId> >::iterator i;
    i = _invokes.find (id);
    if (i == _invokes.end())
        return __null;
    return (*i).second;
}

void
CORBA::ORB::del_invoke (MsgId id)
{
    if (_cache_used && _cache_rec->id() == id) {
        _cache_rec->free();
        _cache_used = 0;
        return;
    }

    map<MsgId, ORBInvokeRec *, less<MsgId> >::iterator i;
    i = _invokes.find (id);
    if (i != _invokes.end()) {
        delete (*i).second;
        _invokes.erase (i);
    }
}

void
CORBA::ORB::dispatcher (Dispatcher *new_disp)
{
    if (new_disp) {

        _disp->move (new_disp);
    }
    if (_disp) {
        delete _disp;
    }
    _disp = new_disp;
}

CORBA::Boolean
CORBA::ORB::is_local (Object_ptr o)
{
# 1712 "orb.cc"
  if (!o->_ior()) {
    return 1;
  }

  IORProfile *p1 = o->_ior()->get_profile (0);
  IORProfile *p2 = _tmpl->get_profile (0);





  if (!p1) {
    return 1;
  }






  if (!p2) {
    return 0;
  }

  ULong i=0, j=0;







  if (p1->id() == 10000) {
    return 1;
  }

  while (p1 && p2) {
    if (!p1->reachable()) {
      p1 = o->_ior()->get_profile (++i);
      continue;
    }
    if (!p2->reachable()) {
      p2 = _tmpl->get_profile (++j);
      continue;
    }

    if (p1->addr()->compare (*p2->addr()) == 0) {
      return 1;
    }

    Long res = p1->compare (*p2);

    ((void) ((res != 0) ? 0 : (__assert_fail ("res != 0", "orb.cc", 1764, __PRETTY_FUNCTION__), 0)));
    if (res < 0) {
      p1 = o->_ior()->get_profile (++i);
    }
    else {
      p2 = _tmpl->get_profile (++j);
    }
  }

  return 0;
}

void
CORBA::ORB::register_oa (ObjectAdapter *oa)
{
  _adapters.push_back (oa);
}

void
CORBA::ORB::unregister_oa (ObjectAdapter *oa)
{
    for (ULong i = 0; i < _adapters.size(); ) {
        if (_adapters[i] == oa)
            _adapters.erase (_adapters.begin() + i);
        else
            ++i;
    }
}

void
CORBA::ORB::register_profile_id (CORBA::ULong id)
{
    if (iiop_proxy_instance)
        iiop_proxy_instance->register_profile_id (id);

    CORBA::DomainManager_var dm;
    get_default_domain_manager (dm);

    CORBA::Policy_var p = dm->get_domain_policy (
        MICOPolicy::TRANSPORTPREF_POLICY_TYPE);

    MICOPolicy::TransportPrefPolicy_var tpp =
        MICOPolicy::TransportPrefPolicy::_narrow (p);

    MICOPolicy::TransportPrefPolicy::
        ProfileTagSeq_var prefs = tpp->preferences();

    for (CORBA::ULong i = 0; i < prefs->length(); ++i) {
        if (prefs[i] == id)
            return;
    }

    prefs->length (prefs->length()+1);
    prefs[prefs->length()-1] = id;

    tpp->preferences (prefs.in());
}

void
CORBA::ORB::unregister_profile_id (CORBA::ULong id)
{
    if (iiop_proxy_instance)
        iiop_proxy_instance->unregister_profile_id (id);

    CORBA::DomainManager_var dm;
    get_default_domain_manager (dm);

    CORBA::Policy_var p = dm->get_domain_policy (
        MICOPolicy::TRANSPORTPREF_POLICY_TYPE);

    MICOPolicy::TransportPrefPolicy_var tpp =
        MICOPolicy::TransportPrefPolicy::_narrow (p);

    MICOPolicy::TransportPrefPolicy::
        ProfileTagSeq_var prefs = tpp->preferences();

    for (CORBA::ULong i = 0; i < prefs->length(); ++i) {
        if (prefs[i] == id) {
            for ( ; i < prefs->length()-1; ++i)
                prefs[i] = prefs[i+1];
            prefs->length (prefs->length()-1);
            tpp->preferences (prefs.in());
            break;
        }
    }
}

CORBA::ObjectAdapter *
CORBA::ORB::get_oa (Object_ptr o)
{
  Boolean local = is_local (o);
  for (ULong i0 = 0; i0 < _adapters.size(); ++i0) {
    if (_adapters[i0]->is_local() == local && _adapters[i0]->has_object (o))
      return _adapters[i0];
  }
  return __null;
}

CORBA::Boolean
CORBA::ORB::builtin_invoke (MsgId msgid, Object_ptr obj,
                            ORBRequest *req, Principal_ptr pr)
{




    if (!strcmp (req->op_name(), "_non_existent")) {
        if (!get_oa (obj)) {
            Any res;
            res <<= Any::from_boolean (1);
            NVList nv;
            if (!req->set_out_args (&res, &nv)) {
                CORBA::MARSHAL ex;
                req->set_out_args (&ex);
                answer_invoke (msgid, InvokeSysEx, Object::_nil(), req, 0);
            } else {
                answer_invoke (msgid, InvokeOk, Object::_nil(), req, 0);
            }
            return 1;
        }
    }
    return 0;
}

CORBA::ORB::MsgId
CORBA::ORB::invoke_async (Object_ptr obj,
                          ORBRequest *req,
                          Principal_ptr pr,
                          Boolean response_exp,
                          ORBCallback *cb,
                          MsgId msgid)
{
    if (msgid == 0)
        msgid = new_msgid();


    _currentid = msgid;

    ORBInvokeRec *rec = 0;
    if (response_exp) {
        rec = create_invoke();
        rec->init_invoke (this, msgid, obj, req, pr, response_exp, cb);
        add_invoke (rec);
    }

    if (!builtin_invoke (msgid, obj, req, pr)) {
        ObjectAdapter *oa = get_oa (obj);
        if (!oa) {
            CORBA::OBJECT_NOT_EXIST ex;
            req->set_out_args (&ex);
            answer_invoke (msgid, InvokeSysEx, Object::_nil(), req, 0);
            return msgid;
        }
        if (response_exp)
            rec->oa (oa);
        oa->invoke (msgid, obj, req, pr, response_exp);
    }
    return response_exp ? msgid : 0;
}

CORBA::ORB::MsgId
CORBA::ORB::locate_async (Object_ptr obj, ORBCallback *cb, MsgId msgid)
{
    ObjectAdapter *oa = get_oa (obj);
    if (msgid == 0)
        msgid = new_msgid();
    ORBInvokeRec *rec = create_invoke();
    rec->init_locate (this, msgid, obj, cb, oa);
    add_invoke (rec);

    if (!oa) {
        answer_locate (msgid, LocateUnknown, Object::_nil(), 0);
    } else {
        oa->locate (msgid, obj);
    }
    return msgid;
}

CORBA::ORB::MsgId
CORBA::ORB::bind_async (const char *repoid,
                        const ObjectTag &oid,
                        Address *addr, ORBCallback *cb,
                        MsgId msgid)
{
    if (msgid == 0)
        msgid = new_msgid();
    ORBInvokeRec *rec = create_invoke();
    rec->init_bind (this, msgid, repoid, oid, addr, cb);
    add_invoke (rec);
    for (ULong i = 0; i < _adapters.size(); ++i) {
        rec->oa (_adapters[i]);
        if (_adapters[i]->bind (msgid, repoid, rec->tag(), addr))
            return msgid;
    }
    answer_bind (msgid, LocateUnknown, Object::_nil());
    return msgid;
}

CORBA::InvokeStatus
CORBA::ORB::invoke (Object_ptr &obj, ORBRequest *req,
                    Principal_ptr pr, Boolean reply_exp)
{
    MsgId id = invoke_async (obj, req, pr, reply_exp);
    if (!reply_exp)
        return InvokeOk;
    ((void) ((id != 0) ? 0 : (__assert_fail ("id != 0", "orb.cc", 1969, __PRETTY_FUNCTION__), 0)));
    CORBA::Boolean r = wait (id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 1971, __PRETTY_FUNCTION__), 0)));
    ORBRequest *dummy;
    CORBA::GIOP::AddressingDisposition adummy;
    return get_invoke_reply (id, obj, dummy, adummy);
}

CORBA::LocateStatus
CORBA::ORB::locate (Object_ptr &obj)
{
    MsgId id = locate_async (obj);
    CORBA::Boolean r = wait (id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 1982, __PRETTY_FUNCTION__), 0)));
    CORBA::GIOP::AddressingDisposition adummy;
    return get_locate_reply (id, obj, adummy);
}

CORBA::LocateStatus
CORBA::ORB::bind (const char *repoid, const ObjectTag &oid,
                  Address *addr, Object_ptr &obj)
{
    MsgId id = bind_async (repoid, oid, addr);
    if (id == 0)
        return LocateUnknown;
    CORBA::Boolean r = wait (id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 1995, __PRETTY_FUNCTION__), 0)));
    return get_bind_reply (id, obj);
}

CORBA::Object_ptr
CORBA::ORB::bind (const char *repoid, const ObjectTag &oid, const char *addr)
{
    vector<string> *addrs, _addrs;
    if (addr) {

        _addrs.push_back (addr);
        addrs = &_addrs;
    } else {

        addrs = &_bindaddrs;
    }

    Address *a;
    for (mico_vec_size_type i = 0; i < addrs->size(); ++i) {
        a = Address::parse ((*addrs)[i].c_str());
        if (a) {
            Object_ptr obj;
            LocateStatus s = bind (repoid, oid, a, obj);
            delete a;
            if (s == LocateHere)
                return obj;
        } else {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: bad bind address: " << (*addrs)[i] << endl;
          }
        }
    }
    return Object::_nil();
}

CORBA::Object_ptr
CORBA::ORB::bind (const char *repoid, const char *addr)
{
    return bind (repoid, ObjectTag(), addr);
}

void
CORBA::ORB::cancel (MsgId id)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (rec) {
        if (rec->oa())
            rec->oa()->cancel (id);
        del_invoke (id);


        _currentid = 0;
    }
}

CORBA::Long
CORBA::ORB::wait (vector<MsgId> &ids, Long tmout)
{
    Timeout t (_disp, tmout);
    ORBInvokeRec *rec;

    while (42) {
        vector<MsgId> ready;
        for (mico_vec_size_type i = 0; i < ids.size(); ++i) {
            rec = get_invoke (ids[i]);
            if (!rec || rec->completed())
                ready.push_back (ids[i]);
        }
        if (ready.size() > 0) {
            ids = ready;
            return ids.size();
        }
        if (t.done())
            return 0;
        _disp->run (0);
    }
}

CORBA::Boolean
CORBA::ORB::wait (MsgId id, Long tmout)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (tmout == 0) {
      if (!rec || rec->completed()) {
        return 1;
      }
    }

    Timeout t (_disp, tmout);

    while (42) {
        if (!rec || rec->completed())
            return 1;
        if (t.done())
            return 0;
        _disp->run (0);
        rec = get_invoke (id);
    }
}

CORBA::InvokeStatus
CORBA::ORB::get_invoke_reply (MsgId id, Object_out obj, ORBRequest *&r,
                              CORBA::GIOP::AddressingDisposition &ad)
{
    ORBInvokeRec *rec = get_invoke (id);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "orb.cc", 2101, __PRETTY_FUNCTION__), 0)));

    InvokeStatus state;
    Object_ptr o;
    CORBA::Boolean ret = rec->get_answer_invoke (state, o, r, ad);
    ((void) ((ret) ? 0 : (__assert_fail ("ret", "orb.cc", 2106, __PRETTY_FUNCTION__), 0)));
    obj = Object::_duplicate (o);
    del_invoke (id);


    _currentid = 0;

    return state;
}

CORBA::LocateStatus
CORBA::ORB::get_locate_reply (MsgId id, Object_out obj,
                              CORBA::GIOP::AddressingDisposition &ad)
{
    ORBInvokeRec *rec = get_invoke (id);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "orb.cc", 2121, __PRETTY_FUNCTION__), 0)));

    LocateStatus state;
    Object_ptr o;
    CORBA::Boolean r = rec->get_answer_locate (state, o, ad);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2126, __PRETTY_FUNCTION__), 0)));
    obj = Object::_duplicate (o);
    del_invoke (id);
    return state;
}

CORBA::LocateStatus
CORBA::ORB::get_bind_reply (MsgId id, Object_out obj)
{
    ORBInvokeRec *rec = get_invoke (id);
    ((void) ((rec) ? 0 : (__assert_fail ("rec", "orb.cc", 2136, __PRETTY_FUNCTION__), 0)));

    LocateStatus state;
    Object_ptr o;
    CORBA::Boolean r = rec->get_answer_bind (state, o);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2141, __PRETTY_FUNCTION__), 0)));
    obj = Object::_duplicate (o);
    del_invoke (id);
    return state;
}

void
CORBA::ORB::answer_invoke (MsgId id, InvokeStatus stat, Object_ptr obj,
                           ORBRequest *req,
                           CORBA::GIOP::AddressingDisposition ad)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (rec) {
        rec->set_answer_invoke (stat, obj, req, ad);
        if (rec->callback())
            rec->callback()->callback (this, rec->id(), ORBCallback::Invoke);
    }
}

void
CORBA::ORB::answer_bind (MsgId id, LocateStatus stat, Object_ptr obj)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (rec) {
        rec->set_answer_bind (stat, obj);
        if (rec->callback())
            rec->callback()->callback (this, rec->id(), ORBCallback::Bind);
    }
}

void
CORBA::ORB::answer_locate (MsgId id, LocateStatus stat, Object_ptr obj,
                           CORBA::GIOP::AddressingDisposition ad)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (rec) {
        rec->set_answer_locate (stat, obj, ad);
        if (rec->callback())
            rec->callback()->callback (this, rec->id(), ORBCallback::Locate);
    }
}

CORBA::RequestType
CORBA::ORB::request_type (MsgId id)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (!rec)
        return RequestUnknown;
    return rec->request_type ();
}

void
CORBA::ORB::redo_request (MsgId id)
{
    ORBInvokeRec *rec = get_invoke (id);
    if (rec) {
        rec->redo();
    } else {
      if (MICO::Logger::IsLogged (MICO::Logger::Info)) {
        MICO::Logger::Stream (MICO::Logger::Info)
          << "Info: no such request " << id << " in redo_request" << endl;
      }
    }
}

CORBA::ImplementationDef_ptr
CORBA::ORB::get_impl (Object_ptr obj)
{

    Request_var req = obj->_request ("_implementation");
    req->result()->value()->set_type (CORBA::_tc_ImplementationDef);
    try { req->invoke (); } catch (...) {};
    if (req->env()->exception())
        mico_throw (*req->env()->exception());
    ImplementationDef_ptr impl;
    CORBA::Boolean r = (*req->result()->value() >>= impl);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2217, __PRETTY_FUNCTION__), 0)));
    return ImplementationDef::_duplicate (impl);
}

CORBA::InterfaceDef_ptr
CORBA::ORB::get_iface (Object_ptr obj)
{

    Request_var req = obj->_request ("_interface");
    req->result()->value()->set_type (CORBA::_tc_InterfaceDef);
    try { req->invoke (); } catch (...) {};
    if (req->env()->exception())
        mico_throw (*req->env()->exception());
    InterfaceDef_ptr iface;
    CORBA::Boolean r = (*req->result()->value() >>= iface);
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2232, __PRETTY_FUNCTION__), 0)));
    return InterfaceDef::_duplicate (iface);
}

CORBA::Boolean
CORBA::ORB::is_a (Object_ptr obj, const char *repo_id)
{

    if (*obj->_repoid()) {
      string key = string(obj->_repoid()) + "$" + repo_id;
      list<string>::iterator i;
      for (i = _isa_cache.begin(); i != _isa_cache.end(); ++i) {
        if (*i == key)
          break;
      }
      if (i != _isa_cache.end()) {
        _isa_cache.erase (i);
        _isa_cache.push_front (key);
        return 1;
      }
    }


    Request_var req = obj->_request ("_is_a");
    req->add_in_arg ("logical_type_id") <<= repo_id;
    req->result()->value()->set_type (CORBA::_tc_boolean);
    try { req->invoke (); } catch (...) {};
    if (req->env()->exception())
        mico_throw (*req->env()->exception());
    Boolean res;
    CORBA::Boolean r = (*req->result()->value() >>= Any::to_boolean (res));
    ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2263, __PRETTY_FUNCTION__), 0)));

    if (res) {
      if (!*obj->_repoid()) {
        obj->_ior()->objid (repo_id);
      }
      else {
        string key = string(obj->_repoid()) + "$" + repo_id;
        _isa_cache.push_front (key);

        if (_isa_cache.size() > 50)
          _isa_cache.pop_back();
      }
    }
    return res;
}

CORBA::Boolean
CORBA::ORB::non_existent (Object_ptr obj)
{

    Request_var req = obj->_request ("_non_existent");
    req->result()->value()->set_type (CORBA::_tc_boolean);
    try { req->invoke (); } catch (...) {};
    Boolean res;
    if (req->env()->exception()) {

        res = 1;
    } else {
        CORBA::Boolean r = (*req->result()->value() >>= Any::to_boolean (res));
        ((void) ((r) ? 0 : (__assert_fail ("r", "orb.cc", 2293, __PRETTY_FUNCTION__), 0)));
    }
    return res;
}

CORBA::ORBInvokeRec *
CORBA::ORB::get_current_invoke_rec ()
{

    if (_currentid == 0)
        return 0;
    return get_invoke (_currentid);
}





CORBA::Principal_ptr
CORBA::PrincipalCurrent_impl::get_principal ()
{
    ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
    ORBInvokeRec *rec = orb->get_current_invoke_rec();
    if (!rec)
        return CORBA::Principal::_nil();
    return CORBA::Principal::_duplicate (rec->principal());
}





CORBA::ORB_ptr
CORBA::ORB_instance (const char *id, Boolean create)
{
    if (strcmp ("mico-local-orb", id)) {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: unknown ORB id " << id << " in ORB_instance" << endl;
      }
      mico_throw (CORBA::INITIALIZE());
    }
    if (create && CORBA::is_nil (orb_instance)) {
        int argc = 0;
        char *argv = 0;
        return ORB_init (argc, &argv, id);
    }
    return ORB::_duplicate (orb_instance);
}

CORBA::ORB_ptr
CORBA::ORB_init (int &argc, char **argv, const char *_id)
{
    OSNet::sock_init();

    Exception::_init ();
    Codeset::_init ();
    MICOPOA::_init ();
# 2367 "orb.cc"
    Boolean run_iiop_server = 1;
    Boolean run_iiop_proxy = 1;
    Boolean iiop_blocking = 0;
    CORBA::Address *fwproxyaddr = 0;
    string imr_ior, imr_addr;
    string ir_ior, ir_addr;
    string naming_ior, naming_addr;
    string trading_ior, trading_addr;
    vector<string> debug_level;
    vector<string> bindaddrs, iiopaddrs;
    string rcfile = "~/.micorc";
    string id = _id;
    vector<string> InitRefs;
    string DefInitRef;
    CORBA::UShort giop_ver, iiop_ver;
    string giop_ver_str = "1.0";
    string iiop_ver_str = "1.0";

    const char *rc = getenv ("MICORC");
    if (rc)
        rcfile = rc;


    {
        MICOGetOpt::OptMap opts;
        opts["-ORBConfFile"] = "arg-expected";

        MICOGetOpt opt_parser (opts);

        if (!opt_parser.parse (argc, argv, 1))
            mico_throw (CORBA::INITIALIZE());
        const MICOGetOpt::OptVec &o = opt_parser.opts();

        MICOGetOpt::OptVec::const_iterator i;
        for (i = o.begin(); i != o.end(); ++i) {
            string arg = (*i).first;
            string val = (*i).second;
            if (arg == "-ORBConfFile") {
                rcfile = val;
            }
        }
    }

    MICOGetOpt::OptMap opts;
    opts["-ORBNoIIOPServer"] = "";
    opts["-ORBNoIIOPProxy"] = "";
    opts["-ORBIIOPAddr"] = "arg-expected";
    opts["-ORBIIOPVersion"] = "arg-expected";
    opts["-ORBGIOPVersion"] = "arg-expected";
    opts["-ORBIIOPProxy"] = "arg-expected";
    opts["-ORBIIOPBlocking"] = "";
    opts["-ORBId"] = "arg-expected";
    opts["-ORBImplRepoIOR"] = "arg-expected";
    opts["-ORBImplRepoAddr"] = "arg-expected";
    opts["-ORBIfaceRepoIOR"] = "arg-expected";
    opts["-ORBIfaceRepoAddr"] = "arg-expected";
    opts["-ORBNamingIOR"] = "arg-expected";
    opts["-ORBNamingAddr"] = "arg-expected";
    opts["-ORBTradingIOR"] = "arg-expected";
    opts["-ORBTradingAddr"] = "arg-expected";
    opts["-ORBDebug"] = "arg-expected";
    opts["-ORBBindAddr"] = "arg-expected";
    opts["-ORBInitRef"] = "arg-expected";
    opts["-ORBDefaultInitRef"]= "arg-expected";
    opts["-ORBNoResolve"] = "";

    MICOGetOpt opt_parser (opts);
    if (!opt_parser.parse (rcfile.c_str(), 1))
        mico_throw (CORBA::INITIALIZE());
    if (!opt_parser.parse (argc, argv, 1))
        mico_throw (CORBA::INITIALIZE());
    const MICOGetOpt::OptVec &o = opt_parser.opts ();

    for (MICOGetOpt::OptVec::const_iterator i = o.begin(); i != o.end(); ++i) {
        string arg = (*i).first;
        string val = (*i).second;
        if (arg == "-ORBNoIIOPServer") {
            run_iiop_server = 0;
        } else if (arg == "-ORBNoIIOPProxy") {
            run_iiop_proxy = 0;
        } else if (arg == "-ORBIIOPAddr") {
            iiopaddrs.push_back (val);
        } else if (arg == "-ORBIIOPProxy") {
          fwproxyaddr = Address::parse (val.c_str());
        } else if (arg == "-ORBIIOPBlocking") {
          iiop_blocking = 1;
        } else if (arg == "-ORBId") {
            if (id.length() == 0)
                id = val;
        } else if (arg == "-ORBImplRepoIOR") {
            imr_ior = val;
        } else if (arg == "-ORBImplRepoAddr") {
            imr_addr = val;
        } else if (arg == "-ORBIfaceRepoIOR") {
            ir_ior = val;
        } else if (arg == "-ORBIfaceRepoAddr") {
            ir_addr = val;
        } else if (arg == "-ORBNamingIOR") {
            naming_ior = val;
        } else if (arg == "-ORBNamingAddr") {
            naming_addr = val;
        } else if (arg == "-ORBTradingIOR") {
            trading_ior = val;
        } else if (arg == "-ORBTradingAddr") {
            trading_addr = val;
        } else if (arg == "-ORBDebug") {
            debug_level.push_back (val);
        } else if (arg == "-ORBBindAddr") {
            bindaddrs.push_back (val);
        } else if (arg == "-ORBInitRef") {
            InitRefs.push_back (val);
        } else if (arg == "-ORBDefaultInitRef") {
            DefInitRef = val;
        } else if (arg == "-ORBNoResolve") {
            MICO::InetAddress::resolve (0);
        } else if (arg == "-ORBGIOPVersion") {
            giop_ver_str = val;
        } else if (arg == "-ORBIIOPVersion") {
            iiop_ver_str = val;
        }
    }


    for (CORBA::ULong debugs=0; debugs<debug_level.size(); debugs++) {
      size_t pos = debug_level[debugs].find ('=');
      string names, file;
      const char * fname;

      if (pos != (size_t) -1) {
        names = debug_level[debugs].substr (0, pos);
        file = debug_level[debugs].substr (pos+1, (size_t) -1);
        fname = file.c_str();
      }
      else {
        names = debug_level[debugs];
        fname = 0;
      }

      while (names.length() > 0) {
        string name;
        if ((pos = names.find (',')) == (size_t) -1) {
          name = names;
          names = "";
        }
        else {
          name = names.substr (0, pos);
          names = names.substr (pos+1);
        }

        MICO::Logger::Log (name.c_str(), 1, fname);
      }
    }

    if (id.length() > 0 && strcmp ("mico-local-orb", id.c_str())) {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: unknown ORB id " << id << " in ORB_init" << endl;
      }
      mico_throw (CORBA::INITIALIZE());
    }

    if (!CORBA::is_nil (orb_instance))
        return ORB::_duplicate (orb_instance);


    orb_instance = new ORB (argc, argv, rcfile.c_str());


    CORBA::Boolean retval =
        Interceptor::InitInterceptor::_exec_initialize (orb_instance,
                                                        "mico-local-orb",
                                                        argc, argv);

    if (!retval)
        mico_throw (CORBA::INITIALIZE());


    orb_instance->bindaddrs (bindaddrs);

    if (giop_ver_str.length() != 3 ||
        giop_ver_str[0] != '1' ||
        giop_ver_str[1] != '.' ||
        giop_ver_str[2] < '0' || giop_ver_str[2] > '2') {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: ORB_init(): invalid GIOP version: "
          << giop_ver_str << endl;
      }
      mico_throw (CORBA::INITIALIZE());
    }
    giop_ver = ((CORBA::UShort)(giop_ver_str[0] - '0') << 8) |
        (giop_ver_str[2] - '0');

    if (iiop_ver_str.length() != 3 ||
        iiop_ver_str[0] != '1' ||
        iiop_ver_str[1] != '.' ||
        iiop_ver_str[2] < '0' || iiop_ver_str[2] > '2') {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: ORB_init(): invalid IIOP version: "
          << iiop_ver_str << endl;
      }
      mico_throw (CORBA::INITIALIZE());
    }
    iiop_ver = ((CORBA::UShort)(iiop_ver_str[0] - '0') << 8) |
        (iiop_ver_str[2] - '0');


    MICO::IIOPProxy::block (iiop_blocking);
    if (run_iiop_proxy) {
        iiop_proxy_instance = new MICO::IIOPProxy (orb_instance, giop_ver);
    }


    if (run_iiop_server) {
        MICO::IIOPServer *server = new MICO::IIOPServer (orb_instance,
                                                         iiop_ver);
        for (mico_vec_size_type i = 0; i < iiopaddrs.size(); ++i) {
            Address *addr = Address::parse (iiopaddrs[i].c_str());
            if (!addr) {
              if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
                MICO::Logger::Stream (MICO::Logger::Error)
                  << "Error: ORB_init(): bad address: "
                  << iiopaddrs[i] << endl;
              }
              mico_throw (CORBA::INITIALIZE());
            }
            if (!server->listen (addr, fwproxyaddr))
                mico_throw (CORBA::INITIALIZE());
            delete addr;
        }
        if (iiopaddrs.size() == 0) {
            server->listen ();
        }
    } else {
        orb_instance->ior_template()->add_profile (
            new MICO::LocalProfile ((Octet *)"", 1));
    }


    Object_var imr;
    if (imr_ior.length() > 0) {
        imr = orb_instance->string_to_object (imr_ior.c_str());
    } else if (imr_addr.length() > 0) {
        imr = orb_instance->bind ("IDL:omg.org/CORBA/ImplRepository:1.0",
                                  imr_addr.c_str());
        if (CORBA::is_nil (imr)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: cannot bind to Implementation Repository at "
              << imr_addr.c_str() << "." << endl
              << "Warning: will use a local Implementation Repository"
              << endl;
          }
        }
    }

    if (!CORBA::is_nil (imr)) {
      orb_instance->set_initial_reference ("ImplementationRepository", imr);
    }
    else {

      orb_instance->set_initial_reference ("ImplementationRepository",
                                           CORBA::Object::_nil());
    }


    Object_var ir;
    if (ir_ior.length() > 0) {
        ir = orb_instance->string_to_object (ir_ior.c_str());
    } else if (ir_addr.length() > 0) {
        ir = orb_instance->bind ("IDL:omg.org/CORBA/Repository:1.0",
                                 ir_addr.c_str());
        if (CORBA::is_nil (ir)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: cannot bind to Interface Repository at "
              << ir_addr.c_str() << "." << endl
              << "Warning: will use a local Interface Repository" << endl;
          }
        }
    }

    if (!CORBA::is_nil (ir)) {
        orb_instance->set_initial_reference ("InterfaceRepository", ir);
    }
    else {

        orb_instance->set_initial_reference ("InterfaceRepository",
                                             CORBA::Object::_nil ());
    }


    Object_var naming;
    if (naming_ior.length() > 0) {
        naming = orb_instance->string_to_object (naming_ior.c_str());
    } else if (naming_addr.length() > 0) {
        CORBA::ORB::ObjectTag_var tag = CORBA::ORB::string_to_tag ("NameService");
        naming = orb_instance->bind ("IDL:omg.org/CosNaming/NamingContext:1.0",
                                     tag.in(), naming_addr.c_str());
        if (CORBA::is_nil (naming)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: cannot bind to Naming Service at "
              << naming_addr.c_str() << "." << endl;
          }
        }
    }
    if (!CORBA::is_nil (naming)) {
        orb_instance->set_initial_reference ("NameService", naming);
    }


    Object_var trading;
    if (trading_ior.length() > 0) {
        trading = orb_instance->string_to_object (trading_ior.c_str());
    } else if (trading_addr.length() > 0) {
        trading = orb_instance->bind ("IDL:omg.org/CosTrading/Lookup:1.0",
                                     trading_addr.c_str());
        if (CORBA::is_nil (trading)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
            MICO::Logger::Stream (MICO::Logger::Warning)
              << "Warning: cannot bind to Trading Service at "
              << trading_addr.c_str() << "." << endl;
          }
        }
    }
    if (!CORBA::is_nil (trading)) {
        orb_instance->set_initial_reference ("TradingService", trading);
    }


    for (CORBA::ULong iref=0; iref<InitRefs.size(); iref++) {
      string id, loc;
      size_t pos = InitRefs[iref].find ('=');
      if (pos == (size_t) -1) {
        mico_throw (CORBA::INITIALIZE());
      }
      id = InitRefs[iref].substr (0, pos);
      loc = InitRefs[iref].substr (pos+1, (size_t) -1);
      CORBA::Object_var iro = orb_instance->string_to_object (loc.c_str());

      if (CORBA::is_nil (iro)) {
        if (MICO::Logger::IsLogged (MICO::Logger::Warning)) {
          MICO::Logger::Stream (MICO::Logger::Warning)
            << "Warning: cannot connect initial reference " << id
            << " at " << loc << endl;
        }
      }
      else {
        orb_instance->set_initial_reference (id.c_str(), iro.in());
      }
    }

    if (DefInitRef.length()) {
      orb_instance->set_default_initial_reference (DefInitRef.c_str());
    }


    ValueFactoryBase_var svf = new StringValue_Factory;
    ValueFactoryBase_var wsvf = new WStringValue_Factory;
    orb_instance->register_value_factory ("IDL:omg.org/CORBA/StringValue:1.0",
                                          svf);
    orb_instance->register_value_factory ("IDL:omg.org/CORBA/WStringValue:1.0",
                                          wsvf);

    return CORBA::ORB::_duplicate (orb_instance);
}
# 17 "orb_all.cc" 2
# 1 "string.cc" 1
# 23 "string.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 24 "string.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 26 "string.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 28 "string.cc" 2
# 1 "../include/mico/util.h" 1
# 29 "string.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 30 "string.cc" 2
# 45 "string.cc"
static const char * the_empty_string = "";

CORBA::String_var::String_var ()
  : _str ((char *) the_empty_string)
{
}

CORBA::String_var::String_var (char *s)
{
  _str = s;
}

CORBA::String_var::String_var (const char *s)
{
  _str = CORBA::string_dup (s);
}

CORBA::String_var::String_var (const String_var &s)
{
  if (s._str == the_empty_string) {
    _str = s._str;
  }
  else {
    _str = CORBA::string_dup (s._str);
  }
}

CORBA::String_var::~String_var ()
{
  if (_str != the_empty_string) {
    CORBA::string_free (_str);
  }
}

CORBA::String_var &
CORBA::String_var::operator= (char *s)
{
  if (_str != the_empty_string) {
    CORBA::string_free (_str);
  }
  _str = s;
  return *this;
}

CORBA::String_var &
CORBA::String_var::operator= (const char *s)
{
  if (_str != the_empty_string) {
    CORBA::string_free (_str);
  }
  _str = CORBA::string_dup (s);
  return *this;
}

CORBA::String_var &
CORBA::String_var::operator= (const String_var &s)
{
  if (this != &s) {
    if (_str != the_empty_string) {
      CORBA::string_free (_str);
    }

    if (s._str == the_empty_string) {
      _str = s._str;
    }
    else {
      _str = CORBA::string_dup (s._str);
    }
  }
  return *this;
}

CORBA::Boolean
CORBA::String_var::operator== (const String_var &s) const
{
  if (!s._str || !_str) {
    return !s._str && !_str;
  }
  return !strcmp (s._str, _str);
}

char *
CORBA::String_var::_retn ()
{
  char *s = _str;
  _str = 0;

  if (s == the_empty_string) {
    s = CORBA::string_dup ("");
  }

  return s;
}

const char *
CORBA::String_var::in () const
{
  return _str;
}

char *&
CORBA::String_var::out ()
{
  if (_str != the_empty_string) {
    CORBA::string_free (_str);
  }
  _str = 0;
  return _str;
}

char *&
CORBA::String_var::inout ()
{
  if (_str == the_empty_string) {
    _str = CORBA::string_dup ("");
  }

  return _str;
}


CORBA::String_out::String_out (char*& s)
    : _str (s)
{
    _str = 0;
}

CORBA::String_out::String_out (String_var& s)
    : _str (s._str)
{
  if (_str != the_empty_string) {
    CORBA::string_free (_str);
  }
  _str = 0;
}

CORBA::String_out::String_out (const String_out& s)
    : _str (s._str)
{
}

CORBA::String_out&
CORBA::String_out::operator= (const String_out& s)
{
    _str = s._str;
    return *this;
}

CORBA::String_out&
CORBA::String_out::operator= (char* s)
{
    _str = s;
    return *this;
}

CORBA::String_out&
CORBA::String_out::operator= (const char* s)
{
    _str = CORBA::string_dup (s);
    return *this;
}


char *
CORBA::string_alloc (ULong len)
{
  char *s = new char[len+1];
  s[0] = 0;
  return s;
}

char *
CORBA::string_dup (const char *s2)
{
  if (!s2)
    return 0;

  char *s = new char[strlen (s2) + 1];
  strcpy (s, s2);
  return s;
}

char *
CORBA::string_ndup (const char *s2, ULong len)
{
  if (!s2)
    return 0;

  char *s = new char[len+1];
  strncpy (s, s2, len);
  s[len] = 0;
  return s;
}

void
CORBA::string_free (char *s)
{
  if (s)
    delete[] s;
}





CORBA::WString_var::WString_var ()
{



    _str = CORBA::wstring_dup (L"");
}

CORBA::WString_var::WString_var (wchar_t *s)
{
    _str = s;
}

CORBA::WString_var::WString_var (const wchar_t *s)
{
    _str = CORBA::wstring_dup (s);
}

CORBA::WString_var::WString_var (const WString_var &s)
{
    _str = CORBA::wstring_dup (s._str);
}

CORBA::WString_var::~WString_var ()
{
    CORBA::wstring_free (_str);
}

CORBA::WString_var &
CORBA::WString_var::operator= (wchar_t *s)
{
    CORBA::wstring_free (_str);
    _str = s;
    return *this;
}

CORBA::WString_var &
CORBA::WString_var::operator= (const wchar_t *s)
{
    CORBA::wstring_free (_str);
    _str = CORBA::wstring_dup (s);
    return *this;
}

CORBA::WString_var &
CORBA::WString_var::operator= (const WString_var &s)
{
    if (this != &s) {
        CORBA::wstring_free (_str);
        _str = CORBA::wstring_dup (s._str);
    }
    return *this;
}

CORBA::Boolean
CORBA::WString_var::operator== (const WString_var &s) const
{
    if (!s._str || !_str)
        return !s._str && !_str;
    return !xwcscmp (s._str, _str);
}

wchar_t *
CORBA::WString_var::_retn ()
{
    wchar_t *s = _str;
    _str = 0;
    return s;
}

const wchar_t *
CORBA::WString_var::in () const
{
    return _str;
}

wchar_t *&
CORBA::WString_var::out ()
{
    CORBA::wstring_free (_str);
    _str = 0;
    return _str;
}

wchar_t *&
CORBA::WString_var::inout ()
{
    return _str;
}


CORBA::WString_out::WString_out (wchar_t*& s)
    : _str (s)
{
    _str = 0;
}

CORBA::WString_out::WString_out (WString_var& s)
    : _str (s._str)
{
    CORBA::wstring_free (_str);
    _str = 0;
}

CORBA::WString_out::WString_out (const WString_out& s)
    : _str (s._str)
{
}

CORBA::WString_out&
CORBA::WString_out::operator= (const WString_out& s)
{
    _str = s._str;
    return *this;
}

CORBA::WString_out&
CORBA::WString_out::operator= (wchar_t* s)
{
    _str = s;
    return *this;
}

CORBA::WString_out&
CORBA::WString_out::operator= (const wchar_t* s)
{
    _str = CORBA::wstring_dup (s);
    return *this;
}



wchar_t *
CORBA::wstring_alloc (ULong len)
{
    wchar_t *s = new wchar_t[len+1];
    s[0] = 0;
    return s;
}

wchar_t *
CORBA::wstring_dup (const wchar_t *s2)
{
    if (!s2)
        return 0;
    wchar_t *s = new wchar_t[xwcslen (s2) + 1];
    xwcscpy (s, s2);
    return s;
}

wchar_t *
CORBA::wstring_ndup (const wchar_t *s2, ULong len)
{
    if (!s2)
        return 0;
    wchar_t *s = new wchar_t[len+1];
    xwcsncpy (s, s2, len);
    s[len] = 0;
    return s;
}

void
CORBA::wstring_free (wchar_t *s)
{
    if (s)
        delete[] s;
}
# 18 "orb_all.cc" 2
# 1 "except.cc" 1
# 25 "except.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "except.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "except.cc" 2

# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 30 "except.cc" 2
# 1 "/opt/gcc3/include/g++-v3/strstream.h" 1 3
# 33 "/opt/gcc3/include/g++-v3/strstream.h" 3
# 1 "/opt/gcc3/include/g++-v3/strstream" 1 3
# 26 "/opt/gcc3/include/g++-v3/strstream" 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_iosfwd.h" 1 3
# 27 "/opt/gcc3/include/g++-v3/strstream" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ios.h" 1 3
# 28 "/opt/gcc3/include/g++-v3/strstream" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_istream.h" 1 3
# 29 "/opt/gcc3/include/g++-v3/strstream" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_ostream.h" 1 3
# 30 "/opt/gcc3/include/g++-v3/strstream" 2 3
# 1 "/opt/gcc3/include/g++-v3/bits/std_string.h" 1 3
# 31 "/opt/gcc3/include/g++-v3/strstream" 2 3

namespace std {





class strstreambuf : public basic_streambuf<char, char_traits<char> >
{
public:
  typedef char_traits<char> _Traits;
  typedef basic_streambuf<char, _Traits> _Base;

public:
  explicit strstreambuf(streamsize __initial_capacity = 0);
  strstreambuf(void* (*__alloc)(size_t), void (*__free)(void*));

  strstreambuf(char* __get, streamsize __n, char* __put = 0);
  strstreambuf(signed char* __get, streamsize __n, signed char* __put = 0);
  strstreambuf(unsigned char* __get, streamsize __n, unsigned char* __put=0);

  strstreambuf(const char* __get, streamsize __n);
  strstreambuf(const signed char* __get, streamsize __n);
  strstreambuf(const unsigned char* __get, streamsize __n);

  virtual ~strstreambuf();

public:
  void freeze(bool = true);
  char* str();
  int pcount() const;

protected:
  virtual int_type overflow(int_type __c = _Traits::eof());
  virtual int_type pbackfail(int_type __c = _Traits::eof());
  virtual int_type underflow();
  virtual _Base* setbuf(char* __buf, streamsize __n);
  virtual pos_type seekoff(off_type __off, ios_base::seekdir __dir,
                           ios_base::openmode __mode
                                      = ios_base::in | ios_base::out);
  virtual pos_type seekpos(pos_type __pos, ios_base::openmode __mode
                                      = ios_base::in | ios_base::out);

private:

  char* _M_alloc(size_t);
  void _M_free(char*);


  void _M_setup(char* __get, char* __put, streamsize __n);

private:
  void* (*_M_alloc_fun)(size_t);
  void (*_M_free_fun)(void*);

  bool _M_dynamic : 1;
  bool _M_frozen : 1;
  bool _M_constant : 1;
};




class istrstream : public basic_istream<char>
{
public:
  explicit istrstream(char*);
  explicit istrstream(const char*);
  istrstream(char* , streamsize);
  istrstream(const char*, streamsize);
  virtual ~istrstream();

  strstreambuf* rdbuf() const;
  char* str();

private:
  strstreambuf _M_buf;
};




class ostrstream : public basic_ostream<char>
{
public:
  ostrstream();
  ostrstream(char*, int, ios_base::openmode = ios_base::out);
  virtual ~ostrstream();

  strstreambuf* rdbuf() const;
  void freeze(bool = true);
  char* str();
  int pcount() const;

private:
  strstreambuf _M_buf;
};




class strstream : public basic_iostream<char>
{
public:
  typedef char char_type;
  typedef char_traits<char>::int_type int_type;
  typedef char_traits<char>::pos_type pos_type;
  typedef char_traits<char>::off_type off_type;

  strstream();
  strstream(char*, int, ios_base::openmode = ios_base::in | ios_base::out);
  virtual ~strstream();

  strstreambuf* rdbuf() const;
  void freeze(bool = true);
  int pcount() const;
  char* str();

private:
  strstreambuf _M_buf;
};

}
# 34 "/opt/gcc3/include/g++-v3/strstream.h" 2 3

using std::strstreambuf;
using std::istrstream;
using std::ostrstream;
using std::strstream;
# 31 "except.cc" 2
# 1 "../include/mico/throw.h" 1
# 32 "except.cc" 2
# 1 "../include/mico/impl.h" 1
# 33 "except.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 34 "except.cc" 2




void (*CORBA::Exception::_old_terminate_handler) () = __null;
# 52 "except.cc"
CORBA::Exception::Exception ()
{
}

CORBA::Exception::Exception (const Exception &e)
{
}

CORBA::Exception::~Exception ()
{
}

CORBA::Exception &
CORBA::Exception::operator= (const Exception &e)
{
    return *this;
}

CORBA::Exception *
CORBA::Exception::_decode (Any &a)
{
    Exception *e;
    if ((e = SystemException::_decode (a)))
        return e;
    if ((e = UserException::_decode (a)))
        return e;
    return __null;
}

CORBA::Exception *
CORBA::Exception::_decode (DataDecoder &dc)
{
    Exception *e;
    ULong rpos = dc.buffer()->rpos();
    if ((e = SystemException::_decode (dc)))
        return e;
    dc.buffer()->rseek_beg (rpos);
    if ((e = UserException::_decode (dc)))
        return e;
    dc.buffer()->rseek_beg (rpos);
    return __null;
}

void
CORBA::Exception::_print (ostream &os) const
{
    os << _repoid();
}

const char *
CORBA::Exception::_repoid () const
{
    return "IDL:omg.org/CORBA/Exception:1.0";
}

CORBA::Exception *
CORBA::Exception::_clone () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 110, __PRETTY_FUNCTION__), 0)));
    return (CORBA::Exception*) 0;
}
# 131 "except.cc"
void
CORBA::Exception::_throwit () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 134, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::Exception::_encode (DataEncoder &ec) const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 140, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::Exception::_encode_any (Any &a) const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 146, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::Exception::_throw_failed (const Exception *ex)
{
    cerr << "exception handling not supported, " << endl;
    cerr << "the following exception has been thrown: " << endl;
    ex->_print (cerr);
    cerr << endl;
    abort ();
}





CORBA::SystemException::SystemException ()
    : _minor (0), _completed (COMPLETED_NO)
{
}

CORBA::SystemException::SystemException (const SystemException &e)
    : _minor (e._minor), _completed (e._completed)
{
}

CORBA::SystemException::SystemException (ULong minor, CompletionStatus status)
    : _minor (minor), _completed (status)
{
}

CORBA::SystemException::~SystemException ()
{
}

CORBA::SystemException &
CORBA::SystemException::operator= (const SystemException &e)
{
    (&e)->_check ();

    if (this != &e) {
        Exception::operator= (e);
        _minor = e._minor;
        _completed = e._completed;
    }
    return *this;
}

const char *
CORBA::SystemException::_repoid () const
{
    return "IDL:omg.org/CORBA/SystemException:1.0";
}

CORBA::Exception *
CORBA::SystemException::_clone () const
{
    return new SystemException (*this);
}

CORBA::SystemException *
CORBA::SystemException::_create_sysex (const char *repoid, ULong minor,
                                       CompletionStatus completed)
{
    if (!strcmp (repoid, "IDL:omg.org/CORBA/SystemException:1.0"))
        return new SystemException (minor, completed);





# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "UNKNOWN" ":1.0")) return new UNKNOWN (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_PARAM" ":1.0")) return new BAD_PARAM (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "NO_MEMORY" ":1.0")) return new NO_MEMORY (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "IMP_LIMIT" ":1.0")) return new IMP_LIMIT (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "COMM_FAILURE" ":1.0")) return new COMM_FAILURE (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INV_OBJREF" ":1.0")) return new INV_OBJREF (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "NO_PERMISSION" ":1.0")) return new NO_PERMISSION (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INTERNAL" ":1.0")) return new INTERNAL (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "MARSHAL" ":1.0")) return new MARSHAL (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INITIALIZE" ":1.0")) return new INITIALIZE (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "NO_IMPLEMENT" ":1.0")) return new NO_IMPLEMENT (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_TYPECODE" ":1.0")) return new BAD_TYPECODE (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_OPERATION" ":1.0")) return new BAD_OPERATION (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "NO_RESOURCES" ":1.0")) return new NO_RESOURCES (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "NO_RESPONSE" ":1.0")) return new NO_RESPONSE (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "PERSIST_STORE" ":1.0")) return new PERSIST_STORE (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_INV_ORDER" ":1.0")) return new BAD_INV_ORDER (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSIENT" ":1.0")) return new TRANSIENT (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "FREE_MEM" ":1.0")) return new FREE_MEM (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INV_IDENT" ":1.0")) return new INV_IDENT (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INV_FLAG" ":1.0")) return new INV_FLAG (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INTF_REPOS" ":1.0")) return new INTF_REPOS (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_CONTEXT" ":1.0")) return new BAD_CONTEXT (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "OBJ_ADAPTER" ":1.0")) return new OBJ_ADAPTER (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "DATA_CONVERSION" ":1.0")) return new DATA_CONVERSION (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "OBJECT_NOT_EXIST" ":1.0")) return new OBJECT_NOT_EXIST (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSACTION_REQUIRED" ":1.0")) return new TRANSACTION_REQUIRED (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSACTION_ROLLEDBACK" ":1.0")) return new TRANSACTION_ROLLEDBACK (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INVALID_TRANSACTION" ":1.0")) return new INVALID_TRANSACTION (minor, completed);
if (!strcmp (repoid, "IDL:omg.org/CORBA/" "INV_POLICY" ":1.0")) return new INV_POLICY (minor, completed);
# 219 "except.cc" 2



    return __null;
}

CORBA::Boolean
CORBA::SystemException::_is_sysex (const char *repoid)
{


    return (!strcmp (repoid, "IDL:omg.org/CORBA/SystemException:1.0")
# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "UNKNOWN" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_PARAM" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "NO_MEMORY" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "IMP_LIMIT" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "COMM_FAILURE" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INV_OBJREF" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "NO_PERMISSION" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INTERNAL" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "MARSHAL" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INITIALIZE" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "NO_IMPLEMENT" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_TYPECODE" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_OPERATION" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "NO_RESOURCES" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "NO_RESPONSE" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "PERSIST_STORE" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_INV_ORDER" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSIENT" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "FREE_MEM" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INV_IDENT" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INV_FLAG" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INTF_REPOS" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "BAD_CONTEXT" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "OBJ_ADAPTER" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "DATA_CONVERSION" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "OBJECT_NOT_EXIST" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSACTION_REQUIRED" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "TRANSACTION_ROLLEDBACK" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INVALID_TRANSACTION" ":1.0")
|| !strcmp (repoid, "IDL:omg.org/CORBA/" "INV_POLICY" ":1.0")
# 232 "except.cc" 2
 );


}

CORBA::SystemException *
CORBA::SystemException::_downcast(Exception *e)
{
    (e)->_check ();

    if (e && _is_sysex (e->_repoid()))
        return (SystemException *)e;
    return __null;
}

const CORBA::SystemException *
CORBA::SystemException::_downcast(const Exception *e)
{
    (e)->_check ();

    if (e && _is_sysex (e->_repoid()))
        return (const SystemException *)e;
    return __null;
}

CORBA::SystemException *
CORBA::SystemException::_decode (Any &a)
{
    ULong k, minor = 0;
    CompletionStatus completed;
    String_var repoid;

    if (!(a.except_get_begin (repoid.out()) &&
          (a >>= minor) &&
          a.enum_get (k) &&
          a.except_get_end ())) {
        return __null;
    }
    completed = (CompletionStatus)k;

    return _create_sysex (repoid, minor, completed);
}

CORBA::SystemException *
CORBA::SystemException::_decode (DataDecoder &dc)
{
    ULong k, minor;
    CompletionStatus completed;
    string repoid;

    if (!(dc.except_begin (repoid) &&
          dc.get_ulong (minor) &&
          dc.enumeration (k) &&
          dc.except_end ())) {
        return __null;
    }
    completed = (CompletionStatus)k;

    return _create_sysex (repoid.c_str(), minor, completed);
}

void
CORBA::SystemException::_print (ostream &os) const
{
    os << _repoid() << " (" << _minor << ", ";
    switch (_completed) {
    case COMPLETED_YES:
        os << "completed";
        break;
    case COMPLETED_NO:
        os << "not-completed";
        break;
    case COMPLETED_MAYBE:
        os << "maybe-completed";
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 308, __PRETTY_FUNCTION__), 0)));
    }
    os << ")";
}

void
CORBA::SystemException::_encode (DataEncoder &ec) const
{
    ec.except_begin (_repoid());
    ec.put_ulong (_minor);
    ec.enumeration ((ULong)_completed);
    ec.except_end ();
}

CORBA::ULong
CORBA::SystemException::minor () const
{
    (this)->_check ();

    return _minor;
}

void
CORBA::SystemException::minor (ULong minor)
{
    (this)->_check ();

    _minor = minor;
}

CORBA::CompletionStatus
CORBA::SystemException::completed () const
{
    (this)->_check ();

    return _completed;
}

void
CORBA::SystemException::completed (CompletionStatus status)
{
    (this)->_check ();

    _completed = status;
}





CORBA::UserException::UserException ()
{
}

CORBA::UserException::UserException (const UserException &)
{
}

CORBA::UserException &
CORBA::UserException::operator= (const UserException &e)
{
    (&e)->_check ();
    return *this;
}

CORBA::UserException::~UserException ()
{
}

void
CORBA::UserException::_throwit () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 380, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::UserException::_print (ostream &os) const
{
    os << _repoid();
}

void
CORBA::UserException::_encode (DataEncoder &ec) const
{
    ec.except_begin ("IDL:omg.org/CORBA/UserException:1.0");
    ec.except_end ();
}

const char *
CORBA::UserException::_repoid () const
{
    return "IDL:omg.org/CORBA/UserException:1.0";
}

CORBA::Exception *
CORBA::UserException::_clone () const
{
    return new UserException (*this);
}

CORBA::UserException *
CORBA::UserException::_downcast (Exception *e)
{
    if (!SystemException::_downcast (e))
        return (UserException *)e;
    return __null;
}

const CORBA::UserException *
CORBA::UserException::_downcast (const Exception *e)
{
    if (!SystemException::_downcast (e))
        return (const UserException *)e;
    return __null;
}

CORBA::UserException *
CORBA::UserException::_decode (Any &a)
{
    return new UnknownUserException (new Any (a));
}

CORBA::UserException *
CORBA::UserException::_decode (DataDecoder &dc)
{
    return new UnknownUserException (dc.clone ());
}





CORBA::UnknownUserException::UnknownUserException (Any *a)
{
    _excpt = a;
    _static_except = 0;
    _dc = 0;
}

CORBA::UnknownUserException::UnknownUserException (DataDecoder *dc)
{
    _excpt = 0;
    _static_except = 0;
    _dc = dc;
}

CORBA::UnknownUserException::UnknownUserException ()
{
    _excpt = new Any;
    _static_except = 0;
    _dc = 0;
}

CORBA::UnknownUserException::UnknownUserException (
    const UnknownUserException &ex)
{
    _excpt = ex._excpt ? new Any (*ex._excpt) : 0;
    _static_except =
        ex._static_except ? new StaticAny (*ex._static_except) : 0;
    _dc = ex._dc ? ex._dc->clone () : 0;
}

CORBA::UnknownUserException &
CORBA::UnknownUserException::operator= (const UnknownUserException &ex)
{
    if (_excpt)
        delete _excpt;
    if (_static_except)
        delete _static_except;
    if (_dc)
        delete _dc;
    _excpt = ex._excpt ? new Any (*ex._excpt) : 0;
    _static_except =
        ex._static_except ? new StaticAny (*ex._static_except) : 0;
    _dc = ex._dc ? ex._dc->clone () : 0;
    return *this;
}

CORBA::UnknownUserException::~UnknownUserException ()
{
    if (_excpt)
        delete _excpt;
    if (_static_except)
        delete _static_except;
    if (_dc)
        delete _dc;
}

CORBA::Any &
CORBA::UnknownUserException::exception (TypeCode_ptr tc)
{
    if (!_excpt) {
        ((void) ((tc) ? 0 : (__assert_fail ("tc", "except.cc", 500, __PRETTY_FUNCTION__), 0)));
        ((void) ((_dc) ? 0 : (__assert_fail ("_dc", "except.cc", 501, __PRETTY_FUNCTION__), 0)));
        _excpt = new Any;
        CORBA::Boolean r = _excpt->demarshal (tc, *_dc);
        ((void) ((r) ? 0 : (__assert_fail ("r", "except.cc", 504, __PRETTY_FUNCTION__), 0)));
    }
    return *_excpt;
}

CORBA::StaticAny &
CORBA::UnknownUserException::exception (StaticTypeInfo *stc)
{
    if (_static_except)
        return *_static_except;

    _static_except = new CORBA::StaticAny (stc);

    if (_excpt) {

        MICO::CDREncoder ec;
        MICO::CDRDecoder dc (ec.buffer(), 0, ec.byteorder(),
                             ec.converter(), 0);

        _excpt->marshal (ec);

        CORBA::Boolean ret = _static_except->demarshal (dc);
        ((void) ((ret) ? 0 : (__assert_fail ("ret", "except.cc", 526, __PRETTY_FUNCTION__), 0)));
    } else {
        ((void) ((_dc) ? 0 : (__assert_fail ("_dc", "except.cc", 528, __PRETTY_FUNCTION__), 0)));
        CORBA::Long rpos = _dc->buffer()->rpos();

        CORBA::Boolean ret = _static_except->demarshal (*_dc);
        ((void) ((ret) ? 0 : (__assert_fail ("ret", "except.cc", 532, __PRETTY_FUNCTION__), 0)));

        _dc->buffer()->rseek_beg (rpos);
    }
    return *_static_except;
}

void
CORBA::UnknownUserException::_encode_any (Any & any) const
{
  ((void) ((_excpt) ? 0 : (__assert_fail ("_excpt", "except.cc", 542, __PRETTY_FUNCTION__), 0)));
  any = *_excpt;
}

void
CORBA::UnknownUserException::_throwit () const
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "except.cc", 549, __PRETTY_FUNCTION__), 0)));
}

void
CORBA::UnknownUserException::_print (ostream &os) const
{
    os << ((UnknownUserException *)this)->_except_repoid()
       << " within " << _repoid();
}

void
CORBA::UnknownUserException::_encode (DataEncoder &ec) const
{
    if (_excpt) {
        _excpt->marshal (ec);
    } else {
        ((void) ((_dc) ? 0 : (__assert_fail ("_dc", "except.cc", 565, __PRETTY_FUNCTION__), 0)));

        ((void) ((!strcmp (ec.type(), _dc->type())) ? 0 : (__assert_fail ("!strcmp (ec.type(), _dc->type())", "except.cc", 567, __PRETTY_FUNCTION__), 0)));
        ec.put_octets (_dc->buffer()->data(), _dc->buffer()->length());
    }
}

const char *
CORBA::UnknownUserException::_except_repoid ()
{
    if (_excpt) {
        String_var repoid;
        CORBA::Boolean r =
            _excpt->except_get_begin (repoid.out()) &&
            _excpt->except_get_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "except.cc", 580, __PRETTY_FUNCTION__), 0)));
        _ex_repoid = repoid;
    } else {
        ((void) ((_dc) ? 0 : (__assert_fail ("_dc", "except.cc", 583, __PRETTY_FUNCTION__), 0)));
        ULong rpos = _dc->buffer()->rpos();
        CORBA::Boolean r = _dc->except_begin (_ex_repoid);
        ((void) ((r) ? 0 : (__assert_fail ("r", "except.cc", 586, __PRETTY_FUNCTION__), 0)));
        _dc->buffer()->rseek_beg (rpos);
    }
    return _ex_repoid.c_str();
}

const char *
CORBA::UnknownUserException::_repoid () const
{
    return "IDL:omg.org/CORBA/UnknownUserException:1.0";
}

CORBA::Exception *
CORBA::UnknownUserException::_clone () const
{
    return new UnknownUserException (*this);
}

CORBA::UnknownUserException *
CORBA::UnknownUserException::_downcast (Exception *e)
{
    if (e && !strcmp (e->_repoid(),
                      "IDL:omg.org/CORBA/UnknownUserException:1.0"))
        return (UnknownUserException *)e;
    return __null;
}

const CORBA::UnknownUserException *
CORBA::UnknownUserException::_downcast (const Exception *e)
{
    if (e && !strcmp (e->_repoid(),
                      "IDL:omg.org/CORBA/UnknownUserException:1.0"))
        return (const UnknownUserException *)e;
    return __null;
}
# 19 "orb_all.cc" 2
# 1 "transport.cc" 1
# 25 "transport.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "transport.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 27 "transport.cc" 2
# 1 "/usr/include/errno.h" 1 3 4
# 28 "transport.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 29 "transport.cc" 2

# 1 "../include/mico/os-net.h" 1
# 31 "transport.cc" 2
# 1 "../include/mico/impl.h" 1
# 32 "transport.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "transport.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "transport.cc" 2





CORBA::TransportCallback::~TransportCallback ()
{
}

CORBA::TransportServer::~TransportServer ()
{
}

CORBA::TransportServerCallback::~TransportServerCallback ()
{
}





CORBA::Transport::~Transport ()
{
}

CORBA::Long
CORBA::Transport::read (Buffer &b, Long len)
{
    b.resize (len);
    Long r = read (b.buffer()+b.wpos(), len);
    if (r > 0)
        b.wseek_rel (r);
    return r;
}

CORBA::Long
CORBA::Transport::write (Buffer &b, Long len, Boolean eat)
{
    ((void) ((len <= b.length()) ? 0 : (__assert_fail ("len <= b.length()", "transport.cc", 72, __PRETTY_FUNCTION__), 0)));
    Long r = write (b.buffer()+b.rpos(), len);
    if (r > 0 && eat)
        b.rseek_rel (r);
    return r;
}

void
CORBA::Transport::buffering (CORBA::Boolean)
{
}

CORBA::Boolean
CORBA::Transport::isbuffering ()
{
    return 0;
}

CORBA::Principal_ptr
CORBA::Transport::get_principal ()
{
    return new CORBA::Principal (this);
}





MICO::TCPTransport::TCPTransport (CORBA::Long thefd)
{
    fd = thefd;
    if (fd < 0) {
        fd = ::socket (2, SOCK_STREAM, 0);
        ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 105, __PRETTY_FUNCTION__), 0)));
    }
    OSNet::sock_block (fd, 1);
    OSNet::sock_ndelay (fd, 1);

    is_blocking = 1;
    is_buffering = 0;
    rdisp = wdisp = 0;
    rcb = wcb = 0;
    ateof = 0;
}

MICO::TCPTransport::~TCPTransport ()
{
    if (rdisp && rcb) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb->callback (this, CORBA::TransportCallback::Remove);
    }
    if (wdisp && wcb) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb->callback (this, CORBA::TransportCallback::Remove);
    }
    OSNet::sock_close (fd);
}

void
MICO::TCPTransport::rselect (CORBA::Dispatcher *disp,
                             CORBA::TransportCallback *cb)
{
    if (rcb && rdisp) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb = 0;
    }
    if (cb) {
        disp->rd_event (this, fd);
        rdisp = disp;
        rcb = cb;
    }
}

void
MICO::TCPTransport::wselect (CORBA::Dispatcher *disp,
                             CORBA::TransportCallback *cb)
{
    if (wcb && wdisp) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb = 0;
    }
    if (cb) {
        disp->wr_event (this, fd);
        wdisp = disp;
        wcb = cb;
    }
}

void
MICO::TCPTransport::callback (CORBA::Dispatcher *disp,
                              CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((rcb) ? 0 : (__assert_fail ("rcb", "transport.cc", 170, __PRETTY_FUNCTION__), 0)));
        rcb->callback (this, CORBA::TransportCallback::Read);
        break;
    case CORBA::Dispatcher::Write:
        ((void) ((wcb) ? 0 : (__assert_fail ("wcb", "transport.cc", 174, __PRETTY_FUNCTION__), 0)));
        wcb->callback (this, CORBA::TransportCallback::Write);
        break;
    case CORBA::Dispatcher::Remove:
        wdisp = rdisp = 0;
        wcb = rcb = 0;
        break;
    case CORBA::Dispatcher::Moved:
        wdisp = rdisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 185, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::TCPTransport::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet\")", "transport.cc", 192, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;

    struct sockaddr_in sin = ia->sockaddr();
    CORBA::Long r = ::bind (fd, (struct sockaddr *)&sin, sizeof (sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::TCPTransport::connect (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet\")", "transport.cc", 208, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;

    struct sockaddr_in sin = ia->sockaddr();
    CORBA::Long r = ::connect (fd, (struct sockaddr *)&sin, sizeof (sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::TCPTransport::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (2, SOCK_STREAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 226, __PRETTY_FUNCTION__), 0)));

    OSNet::sock_ndelay (fd, 1);

    if (rdisp && rcb)
        rdisp->remove (this, CORBA::Dispatcher::Read);
    if (wdisp && wcb)
        wdisp->remove (this, CORBA::Dispatcher::Write);

    is_buffering = 0;
    is_blocking = 1;
    rdisp = wdisp = 0;
    rcb = wcb = 0;
    ateof = 0;
}

void
MICO::TCPTransport::block (CORBA::Boolean doblock)
{
    if (!!is_blocking != !!doblock) {
        is_blocking = doblock;
        OSNet::sock_block (fd, doblock);
    }
}

CORBA::Boolean
MICO::TCPTransport::isblocking ()
{
    return is_blocking;
}

void
MICO::TCPTransport::buffering (CORBA::Boolean dobuffering)
{
    if (!!is_buffering != !!dobuffering) {
        is_buffering = dobuffering;
        OSNet::sock_ndelay (fd, !dobuffering);
    }
}

CORBA::Boolean
MICO::TCPTransport::isbuffering ()
{
    return is_buffering;
}

CORBA::Boolean
MICO::TCPTransport::isreadable ()
{
    fd_set rset;
    struct timeval tm;

    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&rset)->fds_bits)[0]) : "memory"); } while (0);
    __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&rset))->fds_bits)[(((fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) ((fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");

    tm.tv_sec = 0;
    tm.tv_usec = 0;

    int r = ::select (fd+1, (fd_set *)&rset, 0, 0, &tm);
    return r > 0;
}

CORBA::Long
MICO::TCPTransport::read (void *_b, CORBA::Long len)
{
    CORBA::Long todo = len;
    CORBA::Octet *b = (CORBA::Octet *)_b;

    while (todo > 0) {
        CORBA::Long r = OSNet::sock_read (fd, b, todo);
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11 ||
                todo != len)
                break;
            err = xstrerror ((*__errno_location ()));
            return r;
        } else if (r == 0) {
            ateof = 1;
            break;
        }
        b += r;
        todo -= r;
    }
    return len - todo;
}

CORBA::Long
MICO::TCPTransport::write (const void *_b, CORBA::Long len)
{
    CORBA::Long todo = len;
    CORBA::Octet *b = (CORBA::Octet *)_b;

    while (todo > 0) {
        CORBA::Long r = OSNet::sock_write (fd, b, todo);
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11 ||
                todo != len)
                break;
            err = xstrerror ((*__errno_location ()));
            return r;
        } else if (r == 0) {
            break;
        }
        b += r;
        todo -= r;
    }
    return len - todo;
}

const CORBA::Address *
MICO::TCPTransport::addr ()
{
    struct sockaddr_in sin;
    socklen_t sz = sizeof (sin);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&sin, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.sockaddr (sin);
    return &local_addr;
}

const CORBA::Address *
MICO::TCPTransport::peer ()
{
    struct sockaddr_in sin;
    socklen_t sz = sizeof (sin);
    CORBA::Long r = ::getpeername (fd, (struct sockaddr *)&sin, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));


    } else {
        peer_addr.sockaddr (sin);
    }
    return &peer_addr;
}

CORBA::Boolean
MICO::TCPTransport::bad () const
{
    return err.length() > 0;
}

CORBA::Boolean
MICO::TCPTransport::eof () const
{
    return ateof;
}

string
MICO::TCPTransport::errormsg () const
{
    return err;
}





MICO::TCPTransportServer::TCPTransportServer ()
{
    OSNet::sock_init();

    fd = ::socket (2, SOCK_STREAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 402, __PRETTY_FUNCTION__), 0)));

    is_blocking = 1;

    OSNet::sock_reuse (fd, 1);

    listening = 0;
    adisp = 0;
    acb = 0;
}

MICO::TCPTransportServer::~TCPTransportServer ()
{
    if (adisp && acb) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb->callback (this, CORBA::TransportServerCallback::Remove);
    }
    OSNet::sock_close (fd);
}

void
MICO::TCPTransportServer::listen ()
{
    if (!listening) {
        int r = ::listen (fd, 10);
        ((void) ((r == 0) ? 0 : (__assert_fail ("r == 0", "transport.cc", 428, __PRETTY_FUNCTION__), 0)));
        listening = 1;
    }
}

void
MICO::TCPTransportServer::aselect (CORBA::Dispatcher *disp,
                                   CORBA::TransportServerCallback *cb)
{
    if (acb && adisp) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb = 0;
    }
    if (cb) {
        listen ();
        disp->rd_event (this, fd);
        adisp = disp;
        acb = cb;
    }
}

void
MICO::TCPTransportServer::callback (CORBA::Dispatcher *disp,
                                    CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((acb) ? 0 : (__assert_fail ("acb", "transport.cc", 456, __PRETTY_FUNCTION__), 0)));
        acb->callback (this, CORBA::TransportServerCallback::Accept);
        break;
    case CORBA::Dispatcher::Remove:
        acb = 0;
        adisp = 0;
        break;
    case CORBA::Dispatcher::Moved:
        adisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 467, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::TCPTransportServer::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet\")", "transport.cc", 474, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;

    struct sockaddr_in sin = ia->sockaddr();
    CORBA::Long r = ::bind (fd, (struct sockaddr *)&sin, sizeof (sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::TCPTransportServer::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (2, SOCK_STREAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 492, __PRETTY_FUNCTION__), 0)));

    is_blocking = 1;

    OSNet::sock_reuse (fd, 1);

    if (adisp && acb)
        adisp->remove (this, CORBA::Dispatcher::Read);

    listening = 0;
    adisp = 0;
    acb = 0;
}

void
MICO::TCPTransportServer::block (CORBA::Boolean doblock)
{
    if (!!is_blocking != !!doblock) {
        is_blocking = doblock;
        OSNet::sock_block (fd, doblock);
    }
}

CORBA::Boolean
MICO::TCPTransportServer::isblocking ()
{
    return is_blocking;
}

CORBA::Transport *
MICO::TCPTransportServer::accept ()
{
    listen ();
    CORBA::Long newfd = ::accept (fd, 0, 0);
    if (newfd < 0) {
        OSNet::set_errno();
        if ((*__errno_location ()) != 11 && (*__errno_location ()) != 11)
            err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return new TCPTransport (newfd);
}

const CORBA::Address *
MICO::TCPTransportServer::addr ()
{
    struct sockaddr_in sin;
    socklen_t sz = sizeof (sin);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&sin, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.sockaddr (sin);
    return &local_addr;
}

CORBA::Boolean
MICO::TCPTransportServer::bad () const
{
    return err.length() > 0;
}

string
MICO::TCPTransportServer::errormsg () const
{
    return err;
}
# 570 "transport.cc"
MICO::UDPTransport::UDPTransport (CORBA::Long thefd)
{
    fd = thefd;
    if (fd < 0) {
        fd = ::socket (2, SOCK_DGRAM, 0);
        ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 575, __PRETTY_FUNCTION__), 0)));
    }
    OSNet::sock_block (fd, 1);
    OSNet::sock_broadcast (fd, 1);

    is_blocking = 1;
    rdisp = wdisp = 0;
    rcb = wcb = 0;
    is_established = 0;
    is_connected = 0;
    is_bound = 0;
    peer_sin = new sockaddr_in;
    addr_sin = new sockaddr_in;
}

MICO::UDPTransport::~UDPTransport ()
{
    if (rdisp && rcb) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb->callback (this, CORBA::TransportCallback::Remove);
    }
    if (wdisp && wcb) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb->callback (this, CORBA::TransportCallback::Remove);
    }
    OSNet::sock_close (fd);
    delete peer_sin;
    delete addr_sin;
}

void
MICO::UDPTransport::rselect (CORBA::Dispatcher *disp,
                             CORBA::TransportCallback *cb)
{
    if (rcb && rdisp) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb = 0;
    }
    if (cb) {
        disp->rd_event (this, fd);
        rdisp = disp;
        rcb = cb;
    }
}

void
MICO::UDPTransport::wselect (CORBA::Dispatcher *disp,
                             CORBA::TransportCallback *cb)
{
    if (wcb && wdisp) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb = 0;
    }
    if (cb) {
        disp->wr_event (this, fd);
        wdisp = disp;
        wcb = cb;
    }
}

void
MICO::UDPTransport::callback (CORBA::Dispatcher *disp,
                              CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((rcb) ? 0 : (__assert_fail ("rcb", "transport.cc", 645, __PRETTY_FUNCTION__), 0)));
        rcb->callback (this, CORBA::TransportCallback::Read);
        break;
    case CORBA::Dispatcher::Write:
        ((void) ((wcb) ? 0 : (__assert_fail ("wcb", "transport.cc", 649, __PRETTY_FUNCTION__), 0)));
        wcb->callback (this, CORBA::TransportCallback::Write);
        break;
    case CORBA::Dispatcher::Remove:
        wdisp = rdisp = 0;
        wcb = rcb = 0;
        break;
    case CORBA::Dispatcher::Moved:
        wdisp = rdisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 660, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::UDPTransport::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet-dgram")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet-dgram\")", "transport.cc", 667, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;




    *addr_sin = ia->sockaddr();
    is_bound = 1;

    CORBA::Long r = ::bind (fd, (struct sockaddr *)addr_sin, sizeof (*addr_sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::UDPTransport::bind_server (const CORBA::Address *a)
{

    OSNet::sock_reuse (fd, 1);
    return bind (a);
}

CORBA::Long
MICO::UDPTransport::collect_replies (CORBA::Long tmout)
{
    CORBA::Buffer b;
    CORBA::Long replies = 0;
    while (42) {
        fd_set rset;
        struct timeval tm;

        do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&rset)->fds_bits)[0]) : "memory"); } while (0);
        __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&rset))->fds_bits)[(((fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) ((fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");

        tm.tv_sec = tmout / 1000L;
        tm.tv_usec = (tmout % 1000L) * 1000L;

        int r = ::select (fd+1, (fd_set *)&rset, 0, 0, &tm);
        if (r == 0) {

            break;
        }
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4 || (*__errno_location ()) == 11)
                continue;
            ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 717, __PRETTY_FUNCTION__), 0)));
        }
        r = read_dgram (b);
        if (r == 0)
            continue;
        if (r != 30)
            ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 723, __PRETTY_FUNCTION__), 0)));
        if (strncmp ((char *)b.buffer(), ((char *)"CREP-EjAQBgNVBAcTCUZyYW5rZnVyd"), 30))
            ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 725, __PRETTY_FUNCTION__), 0)));
        ++replies;
    }
    return replies;
}

CORBA::Boolean
MICO::UDPTransport::connect (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet-dgram")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet-dgram\")", "transport.cc", 734, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;



    *peer_sin = ia->sockaddr();
    is_connected = 1;

    CORBA::Long retries = 5;
    while (--retries >= 0) {
        if (write (((char *)"CREQ-EjAQBgNVBAcTCUZyYW5rZnVyd"), 30) != 30)
            ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 745, __PRETTY_FUNCTION__), 0)));
        if (collect_replies (300 ) > 0)
            break;
    }
    if (retries < 0) {
        err = "timeout";
        is_connected = 0;
        return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::UDPTransport::connect_server (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet-dgram")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet-dgram\")", "transport.cc", 760, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;

    struct sockaddr_in sin = ia->sockaddr();
    CORBA::Long r = ::connect (fd, (struct sockaddr *)&sin, sizeof (sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::UDPTransport::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (2, SOCK_DGRAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 778, __PRETTY_FUNCTION__), 0)));

    OSNet::sock_broadcast (fd, 1);

    if (rdisp && rcb)
        rdisp->remove (this, CORBA::Dispatcher::Read);
    if (wdisp && wcb)
        wdisp->remove (this, CORBA::Dispatcher::Write);

    is_blocking = 1;
    rdisp = wdisp = 0;
    rcb = wcb = 0;
    is_established = 0;
    is_connected = 0;
    is_bound = 0;
}

void
MICO::UDPTransport::block (CORBA::Boolean doblock)
{
    if (!!is_blocking != !!doblock) {
        is_blocking = doblock;
        OSNet::sock_block (fd, doblock);
    }
}

CORBA::Boolean
MICO::UDPTransport::isblocking ()
{
    return is_blocking;
}

CORBA::Boolean
MICO::UDPTransport::isreadable ()
{
    fd_set rset;
    struct timeval tm;

    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&rset)->fds_bits)[0]) : "memory"); } while (0);
    __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&rset))->fds_bits)[(((fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) ((fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");

    tm.tv_sec = 0;
    tm.tv_usec = 0;

    int r = ::select (fd+1, (fd_set *)&rset, 0, 0, &tm);
    return r > 0;
}

CORBA::Long
MICO::UDPTransport::read_dgram (CORBA::Buffer &buf)
{

    CORBA::ULong dgram_size = 10000;
    buf.reset (dgram_size);

    while (42) {
        CORBA::Long r = OSNet::sock_read (fd, buf.buffer(), dgram_size);
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11)
                return 0;
            err = xstrerror ((*__errno_location ()));
            return r;
        }
        buf.wseek_rel (r);
        return r;
    }

    return 0;
}

CORBA::Long
MICO::UDPTransport::read (void *b, CORBA::Long len)
{
    if (dgram.length() == 0) {
        while (42) {
            CORBA::Long r = read_dgram (dgram);
            if (r <= 0)
                return r;
            if (is_established || r != 30)
                break;
            if (!strncmp((char*)dgram.buffer(),((char *)"CREP-EjAQBgNVBAcTCUZyYW5rZnVyd"),30))

                continue;
            if (!strncmp((char*)dgram.buffer(),((char *)"CREQ-EjAQBgNVBAcTCUZyYW5rZnVyd"),30)){

                if (write (((char *)"CREP-EjAQBgNVBAcTCUZyYW5rZnVyd"), 30) != 30)
                    ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 868, __PRETTY_FUNCTION__), 0)));
                continue;
            }
            break;
        }
        is_established = 1;
    }
    if (len > dgram.length())
        len = dgram.length();
    if (!dgram.get (b, len))
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 878, __PRETTY_FUNCTION__), 0)));

    return len;
}

CORBA::Long
MICO::UDPTransport::write (const void *_b, CORBA::Long len)
{
    CORBA::Octet *b = (CORBA::Octet *)_b;

    while (42) {
        CORBA::Long r;
        if (is_connected) {
            r = OSNet::sock_write_to (fd, b, len,
                                      (struct sockaddr *)peer_sin,
                                      sizeof (*peer_sin));
        } else {
            r = OSNet::sock_write (fd, b, len);
        }
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11)
                return 0;
            err = xstrerror ((*__errno_location ()));
        }
        return r;
    }

    return 0;
}

const CORBA::Address *
MICO::UDPTransport::addr ()
{
    struct sockaddr_in sin;
    socklen_t sz = sizeof (sin);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&sin, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.family (MICO::InetAddress::DGRAM);
    if (is_bound) {
        local_addr.sockaddr (*addr_sin);
        local_addr.port ((__extension__ ({ register unsigned short int __v; if (__builtin_constant_p (sin.sin_port)) __v = ((((sin.sin_port) >> 8) & 0xff) | (((sin.sin_port) & 0xff) << 8)); else __asm__ __volatile__ ("rorw $8, %w0" : "=r" (__v) : "0" ((unsigned short int) (sin.sin_port)) : "cc"); __v; })));
    } else {
        local_addr.sockaddr (sin);
    }
    return &local_addr;
}

const CORBA::Address *
MICO::UDPTransport::peer ()
{
    if (is_connected) {
        peer_addr.family (MICO::InetAddress::DGRAM);
        peer_addr.sockaddr (*peer_sin);
    } else {
        struct sockaddr_in sin;
        socklen_t sz = sizeof (sin);
        CORBA::Long r = ::getpeername (fd, (struct sockaddr *)&sin, &sz);
        if (r < 0) {
            OSNet::set_errno();
            err = xstrerror ((*__errno_location ()));
            return 0;
        } else {
            peer_addr.family (MICO::InetAddress::DGRAM);
            peer_addr.sockaddr (sin);
        }
    }
    return &peer_addr;
}

CORBA::Boolean
MICO::UDPTransport::bad () const
{
    return err.length() > 0;
}

CORBA::Boolean
MICO::UDPTransport::eof () const
{
    return 0;
}

string
MICO::UDPTransport::errormsg () const
{
    return err;
}





MICO::UDPTransportServer::UDPTransportServer ()
{
    OSNet::sock_init();

    fd = ::socket (2, SOCK_DGRAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 982, __PRETTY_FUNCTION__), 0)));

    OSNet::sock_reuse (fd, 1);

    is_blocking = 1;
    is_bound = 0;

    adisp = 0;
    acb = 0;
    addr_sin = new sockaddr_in;
}

MICO::UDPTransportServer::~UDPTransportServer ()
{
    if (adisp && acb) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb->callback (this, CORBA::TransportServerCallback::Remove);
    }
    OSNet::sock_close (fd);
    delete addr_sin;
}

void
MICO::UDPTransportServer::aselect (CORBA::Dispatcher *disp,
                                   CORBA::TransportServerCallback *cb)
{
    if (acb && adisp) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb = 0;
    }
    if (cb) {
        disp->rd_event (this, fd);
        adisp = disp;
        acb = cb;
    }
}

void
MICO::UDPTransportServer::callback (CORBA::Dispatcher *disp,
                                    CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((acb) ? 0 : (__assert_fail ("acb", "transport.cc", 1027, __PRETTY_FUNCTION__), 0)));
        acb->callback (this, CORBA::TransportServerCallback::Accept);
        break;
    case CORBA::Dispatcher::Remove:
        acb = 0;
        adisp = 0;
        break;
    case CORBA::Dispatcher::Moved:
        adisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1038, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::UDPTransportServer::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "inet-dgram")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"inet-dgram\")", "transport.cc", 1045, __PRETTY_FUNCTION__), 0)));
    InetAddress *ia = (InetAddress *)a;




    *addr_sin = ia->sockaddr();
    is_bound = 1;

    CORBA::Long r = ::bind (fd, (struct sockaddr *)addr_sin, sizeof (*addr_sin));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::UDPTransportServer::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (2, SOCK_DGRAM, 0);
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 1068, __PRETTY_FUNCTION__), 0)));

    OSNet::sock_reuse (fd, 1);

    is_blocking = 1;
    is_bound = 0;

    if (adisp && acb)
        adisp->remove (this, CORBA::Dispatcher::Read);

    adisp = 0;
    acb = 0;
}

void
MICO::UDPTransportServer::block (CORBA::Boolean doblock)
{
    if (!!is_blocking != !!doblock) {
        is_blocking = doblock;
        OSNet::sock_block (fd, doblock);
    }
}

CORBA::Boolean
MICO::UDPTransportServer::isblocking ()
{
    return is_blocking;
}

CORBA::Transport *
MICO::UDPTransportServer::accept ()
{
    struct sockaddr_in sin;
    CORBA::Octet b[30 +1];
    CORBA::Long r = OSNet::sock_read_from (fd, b, 30 +1,
                                           (struct sockaddr *)&sin,
                                           sizeof (sin));
    if (r < 0) {
        OSNet::set_errno();
        if ((*__errno_location ()) == 4)
            return 0;

        if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11)
            return 0;
        err = xstrerror ((*__errno_location ()));
        return 0;
    } else if (r == 0) {
        return 0;
    }



    if (r != 30)
        return 0;
    if (strncmp ((char *)b, ((char *)"CREQ-EjAQBgNVBAcTCUZyYW5rZnVyd"), 30))
        return 0;

    UDPTransport *t = new UDPTransport;
    if (!t->bind_server (addr()))
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1127, __PRETTY_FUNCTION__), 0)));

    InetAddress raddr (sin, InetAddress::DGRAM);
    if (!t->connect_server (&raddr))
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1131, __PRETTY_FUNCTION__), 0)));

    if (t->write (((char *)"CREP-EjAQBgNVBAcTCUZyYW5rZnVyd"), 30) != 30)
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1134, __PRETTY_FUNCTION__), 0)));

    return t;
}

const CORBA::Address *
MICO::UDPTransportServer::addr ()
{
    struct sockaddr_in sin;
    socklen_t sz = sizeof (sin);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&sin, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.family (MICO::InetAddress::DGRAM);
    if (is_bound) {
        local_addr.sockaddr (*addr_sin);
        local_addr.port ((__extension__ ({ register unsigned short int __v; if (__builtin_constant_p (sin.sin_port)) __v = ((((sin.sin_port) >> 8) & 0xff) | (((sin.sin_port) & 0xff) << 8)); else __asm__ __volatile__ ("rorw $8, %w0" : "=r" (__v) : "0" ((unsigned short int) (sin.sin_port)) : "cc"); __v; })));
    } else {
        local_addr.sockaddr (sin);
    }
    return &local_addr;
}

CORBA::Boolean
MICO::UDPTransportServer::bad () const
{
    return err.length() > 0;
}

string
MICO::UDPTransportServer::errormsg () const
{
    return err;
}






MICO::UnixTransport::UnixTransport (CORBA::Long thefd)
{
    fd = thefd;
    if (fd < 0) {
        fd = ::socket (1, SOCK_STREAM, 0);
        ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 1182, __PRETTY_FUNCTION__), 0)));
    }
    OSNet::sock_block (fd, 1);

    is_blocking = 1;
    rdisp = wdisp = 0;
    rcb = wcb = 0;
    ateof = 0;
}

MICO::UnixTransport::~UnixTransport ()
{
    if (rdisp && rcb) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb->callback (this, CORBA::TransportCallback::Remove);
    }
    if (wdisp && wcb) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb->callback (this, CORBA::TransportCallback::Remove);
    }
    OSNet::sock_close (fd);
}

void
MICO::UnixTransport::rselect (CORBA::Dispatcher *disp,
                              CORBA::TransportCallback *cb)
{
    if (rcb && rdisp) {
        rdisp->remove (this, CORBA::Dispatcher::Read);
        rdisp = 0;
        rcb = 0;
    }
    if (cb) {
        disp->rd_event (this, fd);
        rdisp = disp;
        rcb = cb;
    }
}

void
MICO::UnixTransport::wselect (CORBA::Dispatcher *disp,
                              CORBA::TransportCallback *cb)
{
    if (wcb && wdisp) {
        wdisp->remove (this, CORBA::Dispatcher::Write);
        wdisp = 0;
        wcb = 0;
    }
    if (cb) {
        disp->wr_event (this, fd);
        wdisp = disp;
        wcb = cb;
    }
}

void
MICO::UnixTransport::callback (CORBA::Dispatcher *disp,
                               CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((rcb) ? 0 : (__assert_fail ("rcb", "transport.cc", 1245, __PRETTY_FUNCTION__), 0)));
        rcb->callback (this, CORBA::TransportCallback::Read);
        break;
    case CORBA::Dispatcher::Write:
        ((void) ((wcb) ? 0 : (__assert_fail ("wcb", "transport.cc", 1249, __PRETTY_FUNCTION__), 0)));
        wcb->callback (this, CORBA::TransportCallback::Write);
        break;
    case CORBA::Dispatcher::Remove:
        wdisp = rdisp = 0;
        wcb = rcb = 0;
        break;
    case CORBA::Dispatcher::Moved:
        wdisp = rdisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1260, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::UnixTransport::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "unix")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"unix\")", "transport.cc", 1267, __PRETTY_FUNCTION__), 0)));
    UnixAddress *ua = (UnixAddress *)a;


    ::unlink (ua->filename());

    struct sockaddr_un una = ua->sockaddr();
    CORBA::Long r = ::bind (fd, (struct sockaddr *)&una, sizeof (una));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

CORBA::Boolean
MICO::UnixTransport::connect (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "unix")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"unix\")", "transport.cc", 1286, __PRETTY_FUNCTION__), 0)));
    UnixAddress *ua = (UnixAddress *)a;

    struct sockaddr_un una = ua->sockaddr();
    CORBA::Long r = ::connect (fd, (struct sockaddr *)&una, sizeof (una));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::UnixTransport::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (1, SOCK_STREAM, 0);
    is_blocking = 1;
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 1305, __PRETTY_FUNCTION__), 0)));

    if (rdisp && rcb)
        rdisp->remove (this, CORBA::Dispatcher::Read);
    if (wdisp && wcb)
        wdisp->remove (this, CORBA::Dispatcher::Write);

    rdisp = wdisp = 0;
    rcb = wcb = 0;
    ateof = 0;
}

void
MICO::UnixTransport::block (CORBA::Boolean doblock)
{
    is_blocking = doblock;
    OSNet::sock_block (fd, doblock);
}

CORBA::Boolean
MICO::UnixTransport::isblocking ()
{
    return is_blocking;
}

CORBA::Boolean
MICO::UnixTransport::isreadable ()
{
    fd_set rset;
    struct timeval tm;

    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&rset)->fds_bits)[0]) : "memory"); } while (0);
    __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&rset))->fds_bits)[(((fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) ((fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");

    tm.tv_sec = 0;
    tm.tv_usec = 0;

    int r = ::select (fd+1, (fd_set *)&rset, 0, 0, &tm);
    return r > 0;
}

CORBA::Long
MICO::UnixTransport::read (void *_b, CORBA::Long len)
{
    CORBA::Long todo = len;
    CORBA::Octet *b = (CORBA::Octet *)_b;

    while (todo > 0) {
        CORBA::Long r = OSNet::sock_read (fd, b, todo);
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11 ||
                todo != len)
                break;
            err = xstrerror ((*__errno_location ()));
            return r;
        } else if (r == 0) {
            ateof = 1;
            break;
        }
        b += r;
        todo -= r;
    }
    return len - todo;
}

CORBA::Long
MICO::UnixTransport::write (const void *_b, CORBA::Long len)
{
    CORBA::Long todo = len;
    CORBA::Octet *b = (CORBA::Octet *)_b;

    while (todo > 0) {
        CORBA::Long r = OSNet::sock_write (fd, b, todo);
        if (r < 0) {
            OSNet::set_errno();
            if ((*__errno_location ()) == 4)
                continue;

            if ((*__errno_location ()) == 0 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11 ||
                todo != len)
                break;
            err = xstrerror ((*__errno_location ()));
            return r;
        } else if (r == 0) {
            break;
        }
        b += r;
        todo -= r;
    }
    return len - todo;
}

const CORBA::Address *
MICO::UnixTransport::addr ()
{
    struct sockaddr_un una;
    socklen_t sz = sizeof (una);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&una, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.sockaddr (una);
    return &local_addr;
}

const CORBA::Address *
MICO::UnixTransport::peer ()
{
    struct sockaddr_un una;
    socklen_t sz = sizeof (una);
    CORBA::Long r = ::getpeername (fd, (struct sockaddr *)&una, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));


    } else {
        peer_addr.sockaddr (una);
    }
    return &peer_addr;
}

CORBA::Boolean
MICO::UnixTransport::bad () const
{
    return err.length() > 0;
}

CORBA::Boolean
MICO::UnixTransport::eof () const
{
    return ateof;
}

string
MICO::UnixTransport::errormsg () const
{
    return err;
}





MICO::UnixTransportServer::UnixTransportServer ()
{
    fd = ::socket (1, SOCK_STREAM, 0);
    is_blocking = 1;
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 1459, __PRETTY_FUNCTION__), 0)));
    listening = 0;
    adisp = 0;
    acb = 0;
}

MICO::UnixTransportServer::~UnixTransportServer ()
{
    if (adisp && acb) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb->callback (this, CORBA::TransportServerCallback::Remove);
    }
    OSNet::sock_close (fd);
}

void
MICO::UnixTransportServer::listen ()
{
    if (!listening) {
        int r = ::listen (fd, 10);
        ((void) ((r == 0) ? 0 : (__assert_fail ("r == 0", "transport.cc", 1480, __PRETTY_FUNCTION__), 0)));
        listening = 1;
    }
}

void
MICO::UnixTransportServer::aselect (CORBA::Dispatcher *disp,
                                    CORBA::TransportServerCallback *cb)
{
    if (acb && adisp) {
        adisp->remove (this, CORBA::Dispatcher::Read);
        adisp = 0;
        acb = 0;
    }
    if (cb) {
        listen ();
        disp->rd_event (this, fd);
        adisp = disp;
        acb = cb;
    }
}

void
MICO::UnixTransportServer::callback (CORBA::Dispatcher *disp,
                                     CORBA::Dispatcher::Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Read:
        ((void) ((acb) ? 0 : (__assert_fail ("acb", "transport.cc", 1508, __PRETTY_FUNCTION__), 0)));
        acb->callback (this, CORBA::TransportServerCallback::Accept);
        break;
    case CORBA::Dispatcher::Remove:
        acb = 0;
        adisp = 0;
        break;
    case CORBA::Dispatcher::Moved:
        adisp = disp;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "transport.cc", 1519, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Boolean
MICO::UnixTransportServer::bind (const CORBA::Address *a)
{
    ((void) ((!strcmp (a->proto(), "unix")) ? 0 : (__assert_fail ("!strcmp (a->proto(), \"unix\")", "transport.cc", 1526, __PRETTY_FUNCTION__), 0)));
    UnixAddress *ua = (UnixAddress *)a;


    ::unlink (ua->filename());

    struct sockaddr_un una = ua->sockaddr();
    CORBA::Long r = ::bind (fd, (struct sockaddr *)&una, sizeof (una));
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return 1;
}

void
MICO::UnixTransportServer::close ()
{
    OSNet::sock_close (fd);
    fd = ::socket (1, SOCK_STREAM, 0);
    is_blocking = 1;
    ((void) ((fd >= 0) ? 0 : (__assert_fail ("fd >= 0", "transport.cc", 1548, __PRETTY_FUNCTION__), 0)));

    if (adisp && acb)
        adisp->remove (this, CORBA::Dispatcher::Read);

    listening = 0;
    adisp = 0;
    acb = 0;
}

void
MICO::UnixTransportServer::block (CORBA::Boolean doblock)
{
    is_blocking = doblock;
    OSNet::sock_block (fd, doblock);
}

CORBA::Boolean
MICO::UnixTransportServer::isblocking ()
{
    return is_blocking;
}

CORBA::Transport *
MICO::UnixTransportServer::accept ()
{
    listen ();
    CORBA::Long newfd = ::accept (fd, 0, 0);
    if (newfd < 0) {
        OSNet::set_errno();
        if ((*__errno_location ()) != 11 && (*__errno_location ()) != 11)
            err = xstrerror ((*__errno_location ()));
        return 0;
    }
    return new UnixTransport (newfd);
}

const CORBA::Address *
MICO::UnixTransportServer::addr ()
{
    struct sockaddr_un una;
    socklen_t sz = sizeof (una);
    CORBA::Long r = ::getsockname (fd, (struct sockaddr *)&una, &sz);
    if (r < 0) {
        OSNet::set_errno();
        err = xstrerror ((*__errno_location ()));
        return 0;
    }
    local_addr.sockaddr (una);
    return &local_addr;
}

CORBA::Boolean
MICO::UnixTransportServer::bad () const
{
    return err.length() > 0;
}

string
MICO::UnixTransportServer::errormsg () const
{
    return err;
}
# 20 "orb_all.cc" 2
# 1 "dispatch.cc" 1
# 25 "dispatch.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "dispatch.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "dispatch.cc" 2

# 1 "/usr/include/errno.h" 1 3 4
# 30 "dispatch.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "dispatch.cc" 2
# 1 "../include/mico/impl.h" 1
# 32 "dispatch.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "dispatch.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "dispatch.cc" 2
# 1 "../include/mico/os-misc.h" 1
# 35 "dispatch.cc" 2
# 1 "../include/mico/os-net.h" 1
# 36 "dispatch.cc" 2





CORBA::Dispatcher::~Dispatcher ()
{
}

CORBA::DispatcherCallback::~DispatcherCallback ()
{
}





CORBA::Timeout::Timeout (Dispatcher *d, Long tm)
    : _ready (tm == 0), _disp (d), _have_tmout (0)
{
    if (tm > 0) {
        _have_tmout = 1;
        _disp->tm_event (this, tm);
    }
}

CORBA::Timeout::~Timeout ()
{
    if (_have_tmout)
        _disp->remove (this, Dispatcher::Timer);
}

void
CORBA::Timeout::callback (Dispatcher *d, Event ev)
{
    switch (ev) {
    case CORBA::Dispatcher::Timer:
        _have_tmout = 0;
        _ready = 1;
        break;

    case CORBA::Dispatcher::Moved:
        _disp = d;
        break;
    }
}




class SignalBlocker {
    OSMisc::SigState _sigs;
    bool _blocked;
public:
    void block ()
    {
        if (!_blocked) {
            _blocked = true;
            OSMisc::block_sigs (_sigs);
        }
    }
    void unblock ()
    {
        if (_blocked) {
            _blocked = false;
            OSMisc::restore_sigs (_sigs);
        }
    }
    SignalBlocker ()
    {
        _blocked = false;
        block();
    }
    ~SignalBlocker ()
    {
        unblock();
    }
};

MICO::SelectDispatcher::SelectDispatcher ()
    : last_update (0), init (1), locked (0), modified (0)
{
    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_wset)->fds_bits)[0]) : "memory"); } while (0);
    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_rset)->fds_bits)[0]) : "memory"); } while (0);
    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_xset)->fds_bits)[0]) : "memory"); } while (0);
    fd_max = 0;
}

MICO::SelectDispatcher::~SelectDispatcher ()
{
    list<FileEvent>::iterator i;
    for (i = fevents.begin(); i != fevents.end(); ++i)
        (*i).cb->callback (this, Remove);

    list<TimerEvent>::iterator j;
    for (j = tevents.begin(); j != tevents.end(); ++j)
        (*j).cb->callback (this, Remove);
}

CORBA::Long
MICO::SelectDispatcher::gettime () const
{
  OSMisc::TimeVal ct = OSMisc::gettime();
  return ct.tv_sec*1000 +ct.tv_usec/1000;
}

void
MICO::SelectDispatcher::sleeptime (OSMisc::TimeVal &tm)
{
    if (tevents.size() == 0) {

        tm.tv_sec = 1;
        tm.tv_usec = 0;
        return;
    }
    update_tevents();
    CORBA::Long t = (tevents.front().delta > 0 ? tevents.front().delta : 0);

    tm.tv_sec = t / 1000L;
    tm.tv_usec = (t % 1000L) * 1000L;
}

void
MICO::SelectDispatcher::update_fevents ()
{
    modified = 1;

    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_rset)->fds_bits)[0]) : "memory"); } while (0);
    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_wset)->fds_bits)[0]) : "memory"); } while (0);
    do { int __d0, __d1; __asm__ __volatile__ ("cld; rep; stosl" : "=c" (__d0), "=D" (__d1) : "a" (0), "0" (sizeof (__fd_set) / sizeof (__fd_mask)), "1" (&((&curr_xset)->fds_bits)[0]) : "memory"); } while (0);
    fd_max = 0;

    list<FileEvent>::iterator i;
    for (i = fevents.begin(); i != fevents.end(); ++i) {
        if (!(*i).deleted) {
            switch ((*i).event) {
            case Read:
                __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&curr_rset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");
                break;
            case Write:
                __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&curr_wset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");
                break;
            case Except:
                __asm__ __volatile__ ("btsl %1,%0" : "=m" ((((&curr_xset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))) : "cc","memory");
                break;
            default:
                ((void) ((0) ? 0 : (__assert_fail ("0", "dispatch.cc", 182, __PRETTY_FUNCTION__), 0)));
            }
            if ((*i).fd > fd_max)
                fd_max = (*i).fd;
        }
    }
}

void
MICO::SelectDispatcher::update_tevents ()
{
    CORBA::Long curr = gettime();
    if (init || tevents.size() == 0 || curr - last_update < 0) {
        last_update = curr;
        init = 0;
    } else {
        tevents.front().delta -= (curr - last_update);
        last_update = curr;
    }
}

void
MICO::SelectDispatcher::handle_tevents ()
{
    SignalBlocker __sb;

    if (tevents.size() == 0)
        return;

    update_tevents ();
    while (tevents.size() > 0 && tevents.front().delta <= 0) {
        TimerEvent t = tevents.front();
        tevents.pop_front();
        if (tevents.size() > 0)
            tevents.front().delta += t.delta;

        __sb.unblock();
        t.cb->callback (this, t.event);
        __sb.block();

        update_tevents ();
    }
}

void
MICO::SelectDispatcher::handle_fevents (FDSet &rset, FDSet &wset, FDSet &xset)
{


    lock ();
    list<FileEvent>::iterator i;

    for (i = fevents.begin(); i != fevents.end(); ++i) {
        if (!(*i).deleted) {
            switch ((*i).event) {
            case Read:
                if ((__extension__ ({register char __result; __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" : "=q" (__result) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))), "m" ((((&rset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "cc"); __result; })))
                    (*i).cb->callback (this, Read);
                break;
            case Write:
                if ((__extension__ ({register char __result; __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" : "=q" (__result) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))), "m" ((((&wset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "cc"); __result; })))
                    (*i).cb->callback (this, Write);
                break;
            case Except:
                if ((__extension__ ({register char __result; __asm__ __volatile__ ("btl %1,%2 ; setcb %b0" : "=q" (__result) : "r" (((int) (((*i).fd))) % (8 * sizeof (__fd_mask))), "m" ((((&xset))->fds_bits)[((((*i).fd)) / (8 * sizeof (__fd_mask)))]) : "cc"); __result; })))
                    (*i).cb->callback (this, Except);
                break;
            default:
                ((void) ((0) ? 0 : (__assert_fail ("0", "dispatch.cc", 250, __PRETTY_FUNCTION__), 0)));
            }
        }
    }
    unlock ();
}

void
MICO::SelectDispatcher::lock ()
{
    if (!locked)
        modified = 0;
    ++locked;
}

void
MICO::SelectDispatcher::unlock ()
{
    if (--locked > 0)
        return;
    ((void) ((locked == 0) ? 0 : (__assert_fail ("locked == 0", "dispatch.cc", 270, __PRETTY_FUNCTION__), 0)));

    if (modified) {
        list<FileEvent>::iterator i, next;
        for (i = fevents.begin(); i != fevents.end(); i = next) {
            next = i;
            ++next;
            if ((*i).deleted)
                fevents.erase (i);
        }
    }
}

CORBA::Boolean
MICO::SelectDispatcher::islocked () const
{
    return locked > 0;
}

void
MICO::SelectDispatcher::rd_event (CORBA::DispatcherCallback *cb,
                                  CORBA::Long fd)
{
    SignalBlocker __sb;

    fevents.push_back (FileEvent (Read, fd, cb));
    update_fevents ();
}

void
MICO::SelectDispatcher::wr_event (CORBA::DispatcherCallback *cb,
                                  CORBA::Long fd)
{
    SignalBlocker __sb;

    fevents.push_back (FileEvent (Write, fd, cb));
    update_fevents ();
}

void
MICO::SelectDispatcher::ex_event (CORBA::DispatcherCallback *cb,
                                  CORBA::Long fd)
{
    SignalBlocker __sb;

    fevents.push_back (FileEvent (Except, fd, cb));
    update_fevents ();
}

void
MICO::SelectDispatcher::tm_event (CORBA::DispatcherCallback *cb,
                                  CORBA::ULong tmout)
{
    SignalBlocker __sb;

    ((void) (((CORBA::Long)tmout >= 0) ? 0 : (__assert_fail ("(CORBA::Long)tmout >= 0", "dispatch.cc", 325, __PRETTY_FUNCTION__), 0)));
    TimerEvent t (Timer, tmout, cb);

    update_tevents ();
    list<TimerEvent>::iterator i;
    for (i = tevents.begin(); i != tevents.end(); ++i) {
        if ((*i).delta <= t.delta) {
            t.delta -= (*i).delta;
        } else {
            (*i).delta -= t.delta;
            break;
        }
    }
    tevents.insert (i, t);
}

void
MICO::SelectDispatcher::remove (CORBA::DispatcherCallback *cb, Event e)
{
    SignalBlocker __sb;

    if (e == All || e == Timer) {
        list<TimerEvent>::iterator i, next;
        for (i = tevents.begin(); i != tevents.end(); i = next) {
            next = i;
            ++next;
            if ((*i).cb == cb) {
                CORBA::Long delta = (*i).delta;
                if (next != tevents.end())
                    (*next).delta += delta;
                tevents.erase (i);
            }
        }
    }
    if (e == All || e == Read || e == Write || e == Except) {
        list<FileEvent>::iterator i, next;
        for (i = fevents.begin(); i != fevents.end(); i = next) {
            next = i;
            ++next;
            if ((*i).cb == cb && (e == All || (*i).event == e)) {
                if (islocked()) {
                    (*i).deleted = 1;
                } else {
                    fevents.erase (i);
                }
            }
        }
        update_fevents ();
    }
}

void
MICO::SelectDispatcher::run (CORBA::Boolean infinite)
{
    FDSet rset, wset, xset;
    OSMisc::TimeVal tm;

    do {
        {
            SignalBlocker __sb;

            rset = curr_rset;
            wset = curr_wset;
            xset = curr_xset;
            sleeptime (tm);
        }

        int r = ::select (fd_max+1,
                          (fd_set *)&rset,
                          (fd_set *)&wset,
                          (fd_set *)&xset,
                          &tm);
        ((void) ((r >= 0 || (*__errno_location ()) == 4 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11) ? 0 : (__assert_fail ("r >= 0 || (*__errno_location ()) == 4 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11", "dispatch.cc", 397, __PRETTY_FUNCTION__), 0)));


        if (r > 0)
            handle_fevents (rset, wset, xset);
        handle_tevents ();
    } while (infinite);
}

void
MICO::SelectDispatcher::move (CORBA::Dispatcher *disp)
{
    SignalBlocker __sb;

    ((void) ((!islocked()) ? 0 : (__assert_fail ("!islocked()", "dispatch.cc", 411, __PRETTY_FUNCTION__), 0)));

    list<FileEvent>::iterator i;
    for (i = fevents.begin(); i != fevents.end(); ++i) {
        switch ((*i).event) {
        case Read:
            (*i).cb->callback (disp, CORBA::Dispatcher::Moved);
            disp->rd_event ((*i).cb, (*i).fd);
            break;
        case Write:
            (*i).cb->callback (disp, CORBA::Dispatcher::Moved);
            disp->wr_event ((*i).cb, (*i).fd);
            break;
        case Except:
            (*i).cb->callback (disp, CORBA::Dispatcher::Moved);
            disp->ex_event ((*i).cb, (*i).fd);
            break;
        default:
            break;
        }
    }
    fevents.erase (fevents.begin(), fevents.end());
    update_fevents ();

    update_tevents ();
    CORBA::Long tmout = 0;
    list<TimerEvent>::iterator j;
    for (j = tevents.begin(); j != tevents.end(); ++j) {
        tmout += (*j).delta;
        if (tmout < 0)
            tmout = 0;
        (*j).cb->callback (disp, CORBA::Dispatcher::Moved);
        disp->tm_event ((*j).cb, tmout);
    }
    tevents.erase (tevents.begin(), tevents.end());
}

CORBA::Boolean
MICO::SelectDispatcher::idle () const
{
  SignalBlocker __sb;
  FDSet rset, wset, xset;
  OSMisc::TimeVal tm;





  if (fevents.size() > 0) {
    rset = curr_rset;
    wset = curr_wset;
    xset = curr_xset;
    tm.tv_sec = 0;
    tm.tv_usec = 0;

    int r = ::select (fd_max+1,
                      (fd_set *)&rset,
                      (fd_set *)&wset,
                      (fd_set *)&xset,
                      &tm);
    ((void) ((r >= 0 || (*__errno_location ()) == 4 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11) ? 0 : (__assert_fail ("r >= 0 || (*__errno_location ()) == 4 || (*__errno_location ()) == 11 || (*__errno_location ()) == 11", "dispatch.cc", 471, __PRETTY_FUNCTION__), 0)));


    if (r > 0) {
      return 0;
    }
  }





  if (tevents.size()) {

    ((SelectDispatcher *) this)->update_tevents ();
    if (tevents.front().delta <= 0) {
      return 0;
    }
  }





  return 1;
}
# 21 "orb_all.cc" 2
# 1 "typecode.cc" 1
# 25 "typecode.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "typecode.cc" 2

# 1 "/usr/include/string.h" 1 3 4
# 28 "typecode.cc" 2

# 1 "/usr/include/ctype.h" 1 3 4
# 30 "typecode.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 31 "typecode.cc" 2
# 1 "../include/mico/impl.h" 1
# 32 "typecode.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "typecode.cc" 2
# 1 "../include/mico/util.h" 1
# 34 "typecode.cc" 2
# 1 "../include/mico/throw.h" 1
# 35 "typecode.cc" 2
# 45 "typecode.cc"
CORBA::TypeCode::TypeCode ()
    : tckind (tk_null), isconst (0)
{
    init ();
}

CORBA::TypeCode::TypeCode (DataDecoder &dc)
    : tckind (tk_null), isconst (0)
{
    init ();
    CORBA::Boolean r = dc.get_typecode (*this);
    ((void) ((r) ? 0 : (__assert_fail ("r", "typecode.cc", 56, __PRETTY_FUNCTION__), 0)));
}

CORBA::TypeCode::TypeCode (const string &s)
    : tckind (tk_null), isconst (0)
{
    init ();
    CORBA::Boolean r = from_string (s.c_str());
    ((void) ((r) ? 0 : (__assert_fail ("r", "typecode.cc", 64, __PRETTY_FUNCTION__), 0)));
}

string
CORBA::TypeCode::stringify () const
{
    MICO::CDREncoder ec;
    ec.put_octet (ec.byteorder() == CORBA::BigEndian ? 0 : 1);
    ec.put_typecode (*this);

    string s;
    Octet o;
    for (Long i = ec.buffer()->length(); --i >= 0; ) {
        ec.buffer()->get (o);
        s += mico_to_xdigit ((o >> 4) & 0xf);
        s += mico_to_xdigit (o & 0xf);
    }
    return s;
}

CORBA::TypeCode::TypeCode (TCKind kindval)
    : tckind (kindval), len (0), isconst (0)
{
    init ();
}

CORBA::TypeCode::TypeCode (const TypeCode &tc)
{
    init ();
    copy (tc);
}

CORBA::TypeCode::~TypeCode ()
{
    free ();
}

CORBA::TypeCode &
CORBA::TypeCode::operator= (const TypeCode &tc)
{
    if (this != &tc) {
        free ();
        copy (tc);
    }
    return *this;
}

CORBA::Boolean
CORBA::TypeCode::from_string (const char *_ior)
{
    string s (_ior);

    free ();
    if ((s.length() & 1) != 0)
        return 0;
    Buffer b;
    for (mico_vec_size_type i = 0; i < s.length(); i += 2) {
        if (!isxdigit (s[i]) || !isxdigit (s[i+1]))
            return 0;
        b.put ((mico_from_xdigit (s[i]) << 4) | mico_from_xdigit (s[i+1]));
    }





    MICO::CDRDecoder dc (&b, 0);


    Octet bo;
    if (!dc.get_octet (bo))
        return 0;
    dc.byteorder (bo ? CORBA::LittleEndian : CORBA::BigEndian);

    if (!dc.get_typecode (*this)) {
        free ();
        return 0;
    }
    return 1;
}

void
CORBA::TypeCode::connect (TypeCode_ptr parent, Long depth)
{




    if (tckind == ((int)0xffffffff)) {
        if (!CORBA::is_nil (recurse_tc))
            return;
        if (recurse_depth == depth ||
            (repoid.length() > 0 && repoid == parent->repoid)) {
            recurse_tc = parent;
            recurse_depth = depth;
        }
        return;
    }

    if (!CORBA::is_nil (content))
        content->connect (parent, depth+1);

    for (mico_vec_size_type i = 0; i < tcvec.size(); ++i)
        tcvec[i]->connect (parent, depth+1);
}

void
CORBA::TypeCode::disconnect (TypeCode_ptr parent)
{




    if (CORBA::is_nil (parent))
        return;

    if (tckind == ((int)0xffffffff)) {
        if (recurse_tc == parent) {
            recurse_tc = _nil();
            if (repoid.length() > 0)
                recurse_depth = -1;
        }
        return;
    }

    if (!CORBA::is_nil (content))
        content->disconnect (parent);

    for (mico_vec_size_type i = 0; i < tcvec.size(); ++i)
        tcvec[i]->disconnect (parent);
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_basic_tc (TCKind k)
{
    return new TypeCode (k);
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_struct_tc (const char *rep_id,
                                   const char *nameval,
                                   const StructMemberSeq &members)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_struct);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    for (CORBA::ULong i = 0; i < members.length(); ++i) {
        tc->namevec.push_back (members[i].name.in());
        tc->tcvec.push_back (CORBA::TypeCode::_duplicate (members[i].type.in()));
        tc->tcvec.back()->connect (tc);
    }
    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_exception_tc (const char *rep_id,
                                      const char *nameval,
                                      const StructMemberSeq &members)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_except);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    for (CORBA::ULong i = 0; i < members.length(); ++i) {
        tc->namevec.push_back (members[i].name.in());
        tc->tcvec.push_back (CORBA::TypeCode::_duplicate (members[i].type.in()));
        tc->tcvec.back()->connect (tc);
    }
    return tc;
}

CORBA::Any *
CORBA::TypeCode::convert_case_label (CORBA::TypeCode_ptr disc,
                                     const CORBA::Any &l)
{
    CORBA::TypeCode_var t = l.type();

    if (disc->equal (t, 1))
        return new CORBA::Any (l);

    switch (t->unalias()->kind()) {
    case CORBA::tk_octet:
        return new CORBA::Any (l);

    case CORBA::tk_short:
    case CORBA::tk_ushort:
    case CORBA::tk_long:
    case CORBA::tk_ulong:
    case CORBA::tk_longlong:
    case CORBA::tk_ulonglong:
        break;
    default:
        mico_throw (CORBA::BAD_PARAM());
    }

    switch (disc->unalias()->kind()) {
    case CORBA::tk_short:
    case CORBA::tk_ushort:
    case CORBA::tk_long:
    case CORBA::tk_ulong:
    case CORBA::tk_longlong:
    case CORBA::tk_ulonglong:
        break;
    default:
        mico_throw (CORBA::BAD_PARAM());
    }

    CORBA::Any_var nl = new CORBA::Any (disc, 0);
    if (!l.coerce (nl.inout()))
        mico_throw (CORBA::BAD_PARAM());
    return nl._retn();
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_union_tc (const char *rep_id, const char *nameval,
                                  TypeCode_ptr disc_type,
                                  const UnionMemberSeq &members)
{
    (disc_type)->_check ();

    CORBA::TypeCode_var tc = new TypeCode (tk_union);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";
    tc->defidx = -1;

    tc->discriminator = CORBA::TypeCode::_duplicate (disc_type);
    TypeCode_var labeltc;
    for (CORBA::ULong i = 0; i < members.length(); ++i) {
        tc->labelvec.push_back (convert_case_label (disc_type, members[i].label));
        labeltc = tc->labelvec.back()->type();
        if (labeltc->kind() == tk_octet) {
            if (tc->defidx >= 0)
                mico_throw (CORBA::BAD_PARAM());
            tc->defidx = i;
        }
        tc->namevec.push_back (members[i].name.in());
        tc->tcvec.push_back (CORBA::TypeCode::_duplicate (members[i].type.in()));
        tc->tcvec.back()->connect (tc);
    }
    return tc._retn();
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_enum_tc (const char *rep_id, const char *nameval,
                                 const EnumMemberSeq &members)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_enum);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    for (CORBA::ULong i = 0; i < members.length(); ++i)
        tc->namevec.push_back (members[i].in());

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_alias_tc (const char *rep_id, const char *nameval,
                                  TypeCode_ptr orig_type)
{
    (orig_type)->_check ();

    CORBA::TypeCode_ptr tc = new TypeCode (tk_alias);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    tc->content = CORBA::TypeCode::_duplicate (orig_type);
    tc->content->connect (tc);

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_interface_tc (const char *rep_id, const char *nameval)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_objref);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_string_tc (ULong bound)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_string);
    tc->len = bound;

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_wstring_tc (ULong bound)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_wstring);
    tc->len = bound;

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_fixed_tc (UShort _digits, Short _scale)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_fixed);
    tc->digits = _digits;
    tc->scale = _scale;

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_array_tc (ULong bound, TypeCode_ptr el_type)
{
    (el_type)->_check ();

    CORBA::TypeCode_ptr tc = new TypeCode (tk_array);
    tc->len = bound;

    tc->content = CORBA::TypeCode::_duplicate (el_type);
    tc->content->connect (tc);

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_sequence_tc (ULong bound, TypeCode_ptr el_type)
{
    (el_type)->_check ();

    CORBA::TypeCode_ptr tc = new TypeCode (tk_sequence);
    tc->len = bound;

    tc->content = CORBA::TypeCode::_duplicate (el_type);
    tc->content->connect (tc);

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_recursive_sequence_tc (ULong bound, ULong offset)
{
    CORBA::TypeCode_ptr tc = new TypeCode (tk_sequence);
    tc->len = bound;

    CORBA::ULong tk_recursive = ((int)0xffffffff);
    tc->content = new TypeCode ((CORBA::TCKind)tk_recursive);
    tc->content->recurse_depth = offset;
    tc->content->connect (tc);

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_value_tc (const char *rep_id, const char *nameval,
                                  ValueModifier mod,
                                  TypeCode_ptr concrete_base,
                                  const ValueMemberSeq &members)
{
    if (!CORBA::is_nil (concrete_base))
        (concrete_base)->_check ();

    CORBA::TypeCode_ptr tc = new CORBA::TypeCode (tk_value);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";
    tc->value_mod = mod;
    tc->len = -1;
    if (!CORBA::is_nil (concrete_base)) {
        tc->content = CORBA::TypeCode::_duplicate (concrete_base);
        tc->content->connect (tc);
    } else {
        tc->content = CORBA::TypeCode::_nil();
    }

    for (CORBA::ULong i = 0; i < members.length(); ++i) {
        tc->visvec.push_back (members[i].access);
        tc->namevec.push_back (members[i].name.in());
        tc->tcvec.push_back (CORBA::TypeCode::_duplicate (members[i].type.in()));
        tc->tcvec.back()->connect (tc);
    }

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_value_box_tc (const char *rep_id,
                                      const char *nameval,
                                      TypeCode_ptr boxed_type)
{
    (boxed_type)->_check ();

    CORBA::TypeCode_ptr tc = new CORBA::TypeCode (tk_value_box);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    tc->content = CORBA::TypeCode::_duplicate (boxed_type);
    tc->content->connect (tc);

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_native_tc (const char *rep_id,
                                   const char *nameval)
{
    CORBA::TypeCode_ptr tc = new CORBA::TypeCode (tk_native);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_recursive_tc (const char *rep_id)
{
    if (!rep_id)
        mico_throw (CORBA::BAD_PARAM());


    CORBA::ULong tk_recursive = ((int)0xffffffff);
    CORBA::TypeCode_ptr tc = new CORBA::TypeCode ((CORBA::TCKind)tk_recursive);
    tc->recurse_depth = -1;
    tc->repoid = rep_id;

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_abstract_interface_tc (const char *rep_id,
                                               const char *nameval)
{
    if (!rep_id || !nameval)
        mico_throw (CORBA::BAD_PARAM());

    CORBA::TypeCode_ptr tc = new CORBA::TypeCode (tk_abstract_interface);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = nameval ? nameval : "";

    return tc;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::create_local_interface_tc (const char *rep_id,
                                            const char *name)
{
    if (!rep_id || !name)
        mico_throw (CORBA::BAD_PARAM());

    CORBA::TypeCode_ptr tc = new CORBA::TypeCode (tk_local_interface);
    tc->repoid = rep_id ? rep_id : "";
    tc->tcname = name ? name : "";

    return tc;
}

void
CORBA::TypeCode::init ()
{
    content = TypeCode::_nil ();
    discriminator = TypeCode::_nil ();
    recurse_tc = TypeCode::_nil ();
}

void
CORBA::TypeCode::copy (const TypeCode &tc)
{
    isconst = 0;
    tckind = tc.tckind;
    tcname = tc.tcname;
    repoid = tc.repoid;
    defidx = tc.defidx;
    len = tc.len;
    digits = tc.digits;
    scale = tc.scale;
    recurse_depth = tc.recurse_depth;
    recurse_tc = TypeCode::_nil();
    namevec = tc.namevec;
    visvec = tc.visvec;
    value_mod = tc.value_mod;

    if (CORBA::is_nil (tc.content))
        content = TypeCode::_nil();
    else {
        content = new TypeCode (*tc.content);
        content->connect (this);
    }

    if (CORBA::is_nil (tc.discriminator))
        discriminator = TypeCode::_nil();
    else {
        discriminator = new TypeCode (*tc.discriminator);
    }

    for (mico_vec_size_type i0 = 0; i0 < tc.tcvec.size(); ++i0) {
        tcvec.push_back (new TypeCode (*tc.tcvec[i0]));
        tcvec.back()->connect (this);
    }

    for (mico_vec_size_type i1 = 0; i1 < tc.labelvec.size(); ++i1)
        labelvec.push_back (new Any (*tc.labelvec[i1]));
}

void
CORBA::TypeCode::free ()
{
    if (!CORBA::is_nil (content)) {
        content->disconnect (this);
        CORBA::release (content);
    }
    if (!CORBA::is_nil (discriminator)) {
        CORBA::release (discriminator);
    }

    content = TypeCode::_nil();
    discriminator = TypeCode::_nil();
    recurse_tc = TypeCode::_nil();

    for (mico_vec_size_type i0 = 0; i0 < tcvec.size(); ++i0) {
        tcvec[i0]->disconnect (this);
        CORBA::release (tcvec[i0]);
    }

    for (mico_vec_size_type i1 = 0; i1 < labelvec.size(); ++i1)
        delete labelvec[i1];

    namevec.erase (namevec.begin(), namevec.end());
    tcvec.erase (tcvec.begin(), tcvec.end());
    labelvec.erase (labelvec.begin(), labelvec.end());
    visvec.erase (visvec.begin(), visvec.end());

    tckind = tk_null;
}

CORBA::TCKind
CORBA::TypeCode::kind () const
{
    (this)->_check ();

    return tckind;
}

CORBA::Boolean
CORBA::TypeCode::equal (TypeCode_ptr tc,
                        Boolean remove_aliases,
                        Boolean ignore_string_bounds) const
{
    (this)->_check ();

    if (this == tc)
        return 1;

    if (remove_aliases) {
        tc = tc->unalias();
        if (tckind == tk_alias)
            return ((TypeCode_ptr)this)->unalias()->equal (tc, remove_aliases,
                                                           ignore_string_bounds);
    }

    if (tckind == ((int)0xffffffff) || tc->tckind == ((int)0xffffffff)) {
        if ((!remove_aliases || 1) && tckind != tc->tckind)
            return 0;
        if (tckind == ((int)0xffffffff) && CORBA::is_nil (recurse_tc))
            return 0;
        if (tc->tckind == ((int)0xffffffff) && CORBA::is_nil (tc->recurse_tc))
            return 0;
        CORBA::TypeCode_ptr metc = resolve_recursion();
        CORBA::TypeCode_ptr hetc = tc->resolve_recursion();
        return metc->tckind == hetc->tckind &&
            !strcmp (metc->id(), hetc->id());
    }

    if (tckind != tc->tckind)
        return 0;





    switch (tckind) {
    case tk_wstring:
    case tk_string:
        if( ignore_string_bounds )
          return true;
        return len == tc->len;

    case tk_fixed:
        return digits == tc->digits && scale == tc->scale;

    case tk_sequence:
    case tk_array:




        return len == tc->len && content->equal (tc->content, remove_aliases,
                                                 ignore_string_bounds);

    case tk_alias:
        return repoid == tc->repoid && content->equal (tc->content,
                                                       remove_aliases,
                                                       ignore_string_bounds);

    case tk_objref:
    case tk_abstract_interface:
    case tk_local_interface:
    case tk_native:
        return repoid == tc->repoid;

    case tk_except:
    case tk_struct:
        {
            if (!(repoid == tc->repoid &&
                  namevec.size() == tc->namevec.size())) {
                return 0;
            }
            ((void) ((namevec.size() == tcvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size()", "typecode.cc", 679, __PRETTY_FUNCTION__), 0)));
            ((void) ((tc->namevec.size() == tc->tcvec.size()) ? 0 : (__assert_fail ("tc->namevec.size() == tc->tcvec.size()", "typecode.cc", 680, __PRETTY_FUNCTION__), 0)));
            for (mico_vec_size_type i = 0; i < tcvec.size(); ++i) {
                if (!tcvec[i]->equal (tc->tcvec[i], remove_aliases,
                                                    ignore_string_bounds)) {
                    return 0;
                }
            }
            return 1;
        }

    case tk_value_box:
        return repoid == tc->repoid && content->equal (tc->content,
                                                       remove_aliases,
                                                       ignore_string_bounds);

    case tk_value:
        {
            if (!(repoid == tc->repoid &&
                  value_mod == tc->value_mod &&
                  namevec.size() == tc->namevec.size())) {
                return 0;
            }
            ((void) ((namevec.size() == tcvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size()", "typecode.cc", 702, __PRETTY_FUNCTION__), 0)));
            ((void) ((namevec.size() == visvec.size()) ? 0 : (__assert_fail ("namevec.size() == visvec.size()", "typecode.cc", 703, __PRETTY_FUNCTION__), 0)));
            ((void) ((tc->namevec.size() == tc->tcvec.size()) ? 0 : (__assert_fail ("tc->namevec.size() == tc->tcvec.size()", "typecode.cc", 704, __PRETTY_FUNCTION__), 0)));
            ((void) ((tc->namevec.size() == tc->visvec.size()) ? 0 : (__assert_fail ("tc->namevec.size() == tc->visvec.size()", "typecode.cc", 705, __PRETTY_FUNCTION__), 0)));
            for (mico_vec_size_type i = 0; i < tcvec.size(); ++i) {
                if (!(tcvec[i]->equal (tc->tcvec[i], remove_aliases,
                                                     ignore_string_bounds) &&
                      visvec[i] == tc->visvec[i])) {
                    return 0;
                }
            }
            return 1;
        }

    case tk_union:
        {
            if (!(repoid == tc->repoid &&
                  namevec.size() == tc->namevec.size() &&
                  discriminator->equal (tc->discriminator, remove_aliases,
                                                      ignore_string_bounds) &&
                ((defidx == tc->defidx) || (defidx < 0 && tc->defidx < 0)))) {
                return 0;
            }
            ((void) ((namevec.size() == tcvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size()", "typecode.cc", 725, __PRETTY_FUNCTION__), 0)));
            ((void) ((namevec.size() == labelvec.size()) ? 0 : (__assert_fail ("namevec.size() == labelvec.size()", "typecode.cc", 726, __PRETTY_FUNCTION__), 0)));
            ((void) ((tc->namevec.size() == tc->tcvec.size()) ? 0 : (__assert_fail ("tc->namevec.size() == tc->tcvec.size()", "typecode.cc", 727, __PRETTY_FUNCTION__), 0)));
            ((void) ((tc->namevec.size() == tc->labelvec.size()) ? 0 : (__assert_fail ("tc->namevec.size() == tc->labelvec.size()", "typecode.cc", 728, __PRETTY_FUNCTION__), 0)));
            for (mico_vec_size_type i = 0; i < tcvec.size(); ++i) {
                if (!(tcvec[i]->equal (tc->tcvec[i], remove_aliases,
                                                      ignore_string_bounds) &&
                    *labelvec[i] == *tc->labelvec[i])) {
                    return 0;
                }
            }
            return 1;
        }
    case tk_enum:
        return repoid == tc->repoid && namevec == tc->namevec;

    case ((int)0xffffffff):
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 742, __PRETTY_FUNCTION__), 0)));

    default:

        return 1;
    }
}

CORBA::Boolean
CORBA::TypeCode::equivalent (TypeCode_ptr tc)
{
  return equaltype (tc);
}

CORBA::Boolean
CORBA::TypeCode::equaltype (TypeCode_ptr tc, SetTC *_cache)
{
    if (this == tc)
        return 1;

    TypeCode_ptr me = unalias()->resolve_recursion();
    while (me->tckind == tk_alias)
        me = me->unalias()->resolve_recursion();

    TypeCode_ptr he = tc->unalias()->resolve_recursion();
    while (he->tckind == tk_alias)
        he = he->unalias()->resolve_recursion();




    if (me->tckind != he->tckind)
        return 0;




    switch (me->tckind) {
    case tk_void:
    case tk_null:
    case tk_short:
    case tk_ushort:
    case tk_octet:
    case tk_boolean:
    case tk_char:
    case tk_wchar:
    case tk_any:
    case tk_TypeCode:
    case tk_Principal:
    case tk_long:
    case tk_longlong:
    case tk_ulong:
    case tk_ulonglong:
    case tk_float:
    case tk_double:
    case tk_longdouble:
        return 1;

    case tk_string:
    case tk_wstring:
        return me->len == he->len;

    case tk_objref:
    case tk_abstract_interface:
    case tk_local_interface:
    case tk_native:
        return me->repoid == he->repoid;

    case tk_enum:
        return me->namevec == he->namevec;

    case tk_fixed:
        return me->digits == he->digits && me->scale == he->scale;

    case tk_alias:
    case ((int)0xffffffff):

        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 819, __PRETTY_FUNCTION__), 0)));

    default:
        break;
    }




    if (_cache && _cache->count (make_pair (me, he)))
        return 1;




    SetTC *cache = _cache ? _cache : new SetTC;
    cache->insert (make_pair (me, he));

    Boolean retval = 0;

    switch (me->tckind) {
    case tk_sequence:
    case tk_array:
        retval = (me->len == he->len &&
                  me->content->equaltype (he->content, cache));
        break;

    case tk_except:
    case tk_struct:
        {
            if (me->namevec.size() != he->namevec.size())
                break;
            ((void) ((me->namevec.size() == me->tcvec.size()) ? 0 : (__assert_fail ("me->namevec.size() == me->tcvec.size()", "typecode.cc", 851, __PRETTY_FUNCTION__), 0)));
            ((void) ((he->namevec.size() == he->tcvec.size()) ? 0 : (__assert_fail ("he->namevec.size() == he->tcvec.size()", "typecode.cc", 852, __PRETTY_FUNCTION__), 0)));
            retval = 1;
            for (mico_vec_size_type i=0; i < me->tcvec.size(); ++i) {
                if (!me->tcvec[i]->equaltype (he->tcvec[i], cache)) {
                    retval = 0;
                    break;
                }
            }
            break;
        }
    case tk_value_box:
        retval = me->content->equaltype (he->content, cache);
        break;

    case tk_value:
        {
            if (me->value_mod != he->value_mod ||
                me->namevec.size() != he->namevec.size())
                break;

            ((void) ((me->namevec.size() == me->tcvec.size()) ? 0 : (__assert_fail ("me->namevec.size() == me->tcvec.size()", "typecode.cc", 872, __PRETTY_FUNCTION__), 0)));
            ((void) ((me->namevec.size() == me->visvec.size()) ? 0 : (__assert_fail ("me->namevec.size() == me->visvec.size()", "typecode.cc", 873, __PRETTY_FUNCTION__), 0)));
            ((void) ((he->namevec.size() == he->tcvec.size()) ? 0 : (__assert_fail ("he->namevec.size() == he->tcvec.size()", "typecode.cc", 874, __PRETTY_FUNCTION__), 0)));
            ((void) ((he->namevec.size() == he->visvec.size()) ? 0 : (__assert_fail ("he->namevec.size() == he->visvec.size()", "typecode.cc", 875, __PRETTY_FUNCTION__), 0)));
            retval = 1;
            for (mico_vec_size_type i = 0; i < me->tcvec.size(); ++i) {
                if (!me->tcvec[i]->equaltype (he->tcvec[i]) ||
                    me->visvec[i] != he->visvec[i]) {
                    retval = 0;
                    break;
                }
            }
            break;
        }
    case tk_union:
        {
            if (me->namevec.size() != he->namevec.size() ||
                !me->discriminator->equaltype (he->discriminator, cache))
                break;

            ((void) ((me->namevec.size() == me->tcvec.size()) ? 0 : (__assert_fail ("me->namevec.size() == me->tcvec.size()", "typecode.cc", 892, __PRETTY_FUNCTION__), 0)));
            ((void) ((me->namevec.size() == me->labelvec.size()) ? 0 : (__assert_fail ("me->namevec.size() == me->labelvec.size()", "typecode.cc", 893, __PRETTY_FUNCTION__), 0)));
            ((void) ((he->namevec.size() == he->tcvec.size()) ? 0 : (__assert_fail ("he->namevec.size() == he->tcvec.size()", "typecode.cc", 894, __PRETTY_FUNCTION__), 0)));
            ((void) ((he->namevec.size() == he->labelvec.size()) ? 0 : (__assert_fail ("he->namevec.size() == he->labelvec.size()", "typecode.cc", 895, __PRETTY_FUNCTION__), 0)));
            retval = 1;
            for (mico_vec_size_type i=0; i < me->tcvec.size(); ++i) {
                if (!me->tcvec[i]->equaltype (he->tcvec[i], cache) ||
                    !(*me->labelvec[i] == *he->labelvec[i])) {
                    retval = 0;
                    break;
                }
            }
            break;
        }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 907, __PRETTY_FUNCTION__), 0)));
    }




    if (!retval)
        cache->erase (make_pair (me, he));

    if (!_cache)
        delete cache;

    return retval;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::resolve_recursion() const
{
    if (tckind != ((int)0xffffffff))
        return (TypeCode_ptr)this;

    ((void) ((!CORBA::is_nil (recurse_tc)) ? 0 : (__assert_fail ("!CORBA::is_nil (recurse_tc)", "typecode.cc", 928, __PRETTY_FUNCTION__), 0)));
    return recurse_tc;
}

const char *
CORBA::TypeCode::id () const
{
    (this)->_check ();

    if (!(tckind == tk_objref || tckind == tk_struct ||
          tckind == tk_union || tckind == tk_enum ||
          tckind == tk_alias || tckind == tk_except ||
          tckind == tk_native || tckind == tk_abstract_interface ||
          tckind == tk_local_interface ||
          tckind == tk_value || tckind == tk_value_box ||
          (tckind == ((int)0xffffffff) && repoid.length() > 0)))
        mico_throw (CORBA::TypeCode::BadKind());
    return repoid.c_str();
}

const char *
CORBA::TypeCode::name () const
{
    if (!(tckind == tk_objref || tckind == tk_struct ||
          tckind == tk_union || tckind == tk_enum ||
          tckind == tk_alias || tckind == tk_except ||
          tckind == tk_native || tckind == tk_abstract_interface ||
          tckind == tk_local_interface ||
          tckind == tk_value || tckind == tk_value_box))
        mico_throw (CORBA::TypeCode::BadKind());
    return tcname.c_str();
}

CORBA::Long
CORBA::TypeCode::member_index (const Any &a)
{
    if (tckind != tk_union)
        mico_throw (CORBA::TypeCode::BadKind());

    for (mico_vec_size_type i = 0; i < labelvec.size(); ++i) {
        if (a == *labelvec[i])
            return i;
    }
    return defidx;
}

CORBA::Long
CORBA::TypeCode::member_index (const char *s)
{
    if (!(tckind == tk_union || tckind == tk_enum ||
          tckind == tk_struct || tckind == tk_except ||
          tckind == tk_value))
        mico_throw (CORBA::TypeCode::BadKind());

    for (mico_vec_size_type i = 0; i < namevec.size(); ++i) {
        if (!strcmp (s, namevec[i].c_str()))
            return i;
    }
    return -1;
}

CORBA::ULong
CORBA::TypeCode::member_count () const
{
    (this)->_check ();

    if (!(tckind == tk_struct || tckind == tk_union ||
          tckind == tk_enum || tckind == tk_except ||
          tckind == tk_value))
        mico_throw (CORBA::TypeCode::BadKind());
    return namevec.size();
}

const char *
CORBA::TypeCode::member_name (ULong idx) const
{
    (this)->_check ();

    if (!(tckind == tk_struct || tckind == tk_union ||
          tckind == tk_enum || tckind == tk_except ||
          tckind == tk_value))
        mico_throw (CORBA::TypeCode::BadKind());
    if (idx >= namevec.size())
        mico_throw (CORBA::TypeCode::Bounds());
    return namevec[idx].c_str();
}

CORBA::TypeCode_ptr
CORBA::TypeCode::member_type (ULong idx) const
{
    (this)->_check ();

    if (!(tckind == tk_struct || tckind == tk_union ||
            tckind == tk_except || tckind == tk_value))
        mico_throw (CORBA::TypeCode::BadKind());
    if (idx >= tcvec.size())
        mico_throw (CORBA::TypeCode::Bounds());
    return TypeCode::_duplicate (tcvec[idx]->resolve_recursion());
}

CORBA::Any *
CORBA::TypeCode::member_label (ULong idx) const
{
    (this)->_check ();

    if (tckind != tk_union)
        mico_throw (CORBA::TypeCode::BadKind());
    if (idx >= labelvec.size())
        mico_throw (CORBA::TypeCode::Bounds());
    return new CORBA::Any (*labelvec[idx]);
}

CORBA::TypeCode_ptr
CORBA::TypeCode::discriminator_type () const
{
    (this)->_check ();

    if (tckind != tk_union)
        mico_throw (CORBA::TypeCode::BadKind());
    return TypeCode::_duplicate (discriminator);
}

CORBA::Long
CORBA::TypeCode::default_index () const
{
    (this)->_check ();

    if (tckind != tk_union)
        mico_throw (CORBA::TypeCode::BadKind());
    return defidx;
}

CORBA::ULong
CORBA::TypeCode::length () const
{
    (this)->_check ();

    if (!(tckind == tk_string || tckind == tk_sequence ||
          tckind == tk_array || tckind == tk_wstring))
        mico_throw (CORBA::TypeCode::BadKind());
    return len;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::content_type () const
{
    (this)->_check ();

    if (!(tckind == tk_sequence || tckind == tk_array ||
          tckind == tk_alias || tckind == tk_value_box))
        mico_throw (CORBA::TypeCode::BadKind());
    return TypeCode::_duplicate (content->resolve_recursion());
}

CORBA::UShort
CORBA::TypeCode::fixed_digits () const
{
    if (!(tckind == tk_fixed))
        mico_throw (CORBA::TypeCode::BadKind());
    return digits;
}

CORBA::Short
CORBA::TypeCode::fixed_scale () const
{
    if (!(tckind == tk_fixed))
        mico_throw (CORBA::TypeCode::BadKind());
    return scale;
}

CORBA::Visibility
CORBA::TypeCode::member_visibility (ULong idx) const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());
    if (idx >= visvec.size())
        mico_throw (CORBA::TypeCode::Bounds());
    return visvec[idx];
}

CORBA::ValueModifier
CORBA::TypeCode::type_modifier() const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());
    return value_mod;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::concrete_base_type() const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());
    return CORBA::TypeCode::_duplicate (content);
}

void
CORBA::TypeCode::strip()
{
    tcname = "";

    mico_vec_size_type i;
    for (i = 0; i < namevec.size(); ++i)
        namevec[i] = "";

    for (i = 0; i < tcvec.size(); ++i)
        tcvec[i]->strip();

    if (!CORBA::is_nil (content))
        content->strip();
}

CORBA::TypeCode_ptr
CORBA::TypeCode::get_compact_typecode() const
{
    CORBA::TypeCode_ptr t = new TypeCode(*this);
    t->strip();
    return t;
}

CORBA::ULong
CORBA::TypeCode::member_count_inherited () const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());

    TypeCode_ptr me = (TypeCode_ptr)this;

    if (len < 0) {
        me->len = member_count();
        if (!CORBA::is_nil (content))
            me->len += content->member_count_inherited();
    }
    return len;
}

const char *
CORBA::TypeCode::member_name_inherited (ULong idx) const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());

    ULong n = member_count_inherited();
    if (idx >= n)
        mico_throw (CORBA::TypeCode::Bounds());
    idx = n-1 -idx;

    TypeCode_ptr t = (TypeCode_ptr)this;

    while (42) {
        n = t->member_count();
        if (idx < n)
            break;
        idx -= n;
        t = t->content;
        ((void) ((!CORBA::is_nil (t)) ? 0 : (__assert_fail ("!CORBA::is_nil (t)", "typecode.cc", 1183, __PRETTY_FUNCTION__), 0)));
    }
    return t->member_name (n-1 -idx);
}

CORBA::TypeCode_ptr
CORBA::TypeCode::member_type_inherited (ULong idx) const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());

    ULong n = member_count_inherited();
    if (idx >= n)
        mico_throw (CORBA::TypeCode::Bounds());
    idx = n-1 -idx;

    TypeCode_ptr t = (TypeCode_ptr)this;

    while (42) {
        n = t->member_count();
        if (idx < n)
            break;
        idx -= n;
        t = t->content;
        ((void) ((!CORBA::is_nil (t)) ? 0 : (__assert_fail ("!CORBA::is_nil (t)", "typecode.cc", 1207, __PRETTY_FUNCTION__), 0)));
    }
    return t->member_type (n-1 -idx);
}

CORBA::Visibility
CORBA::TypeCode::member_visibility_inherited (ULong idx) const
{
    if (tckind != tk_value)
        mico_throw (CORBA::TypeCode::BadKind());

    ULong n = member_count_inherited();
    if (idx >= n)
        mico_throw (CORBA::TypeCode::Bounds());
    idx = n-1 -idx;

    TypeCode_ptr t = (TypeCode_ptr)this;

    while (42) {
        n = t->member_count();
        if (idx < n)
            break;
        idx -= n;
        t = t->content;
        ((void) ((!CORBA::is_nil (t)) ? 0 : (__assert_fail ("!CORBA::is_nil (t)", "typecode.cc", 1231, __PRETTY_FUNCTION__), 0)));
    }
    return t->member_visibility (n-1 -idx);
}

CORBA::Long
CORBA::TypeCode::param_count () const
{
    switch (tckind) {
    case tk_string:
    case tk_wstring:
    case tk_objref:
    case tk_abstract_interface:
    case tk_local_interface:
    case tk_native:
        return 1;
    case tk_sequence:
    case tk_array:
    case tk_alias:
    case tk_fixed:
    case tk_value_box:
        return 2;
    case tk_enum:
        return 1 + namevec.size();
    case tk_except:
    case tk_struct:
        return 1 + 2 * namevec.size();
    case tk_union:
        return 2 + 3 * namevec.size();
    case tk_value:
        return 3 + 3 * namevec.size();
    default:
        return 0;
    }
}

CORBA::Any *
CORBA::TypeCode::parameter (Long idx) const
{
    if (idx < 0 || idx >= param_count())
        mico_throw (CORBA::TypeCode::Bounds());

    Any *a = new Any;

    switch (tckind) {
    case tk_string:
    case tk_wstring:
        *a <<= length();
        break;

    case tk_objref:
    case tk_native:
    case tk_abstract_interface:
    case tk_local_interface:
        *a <<= id();
        break;

    case tk_sequence:
    case tk_array:
        if (idx == 0) {
            TypeCode_var t = content_type();
            *a <<= t;
        } else {
            *a <<= length();
        }
        break;

    case tk_alias:
    case tk_value_box:
        if (idx == 0) {
            *a <<= name();
        } else {
            TypeCode_var t = content_type();
            *a <<= t;
        }
        break;

    case tk_enum:
        if (idx == 0) {
            *a <<= name();
        } else {
            *a <<= member_name (idx-1);
        }
        break;

    case tk_fixed:
        if (idx == 0) {
            *a <<= fixed_digits();
        } else {
            *a <<= fixed_scale();
        }
        break;

    case tk_except:
    case tk_struct:
        if (idx == 0) {
            *a <<= name();
        } else if ((idx-1) % 2 == 0) {
            *a <<= member_name ((idx-1) / 2);
        } else {
            TypeCode_var t = member_type ((idx-1) / 2);
            *a <<= t;
        }
        break;

    case tk_union:
        if (idx == 0) {
            *a <<= name();
        } else if (idx == 1) {
            TypeCode_var t = discriminator_type();
            *a <<= t;
        } else if ((idx-2) % 3 == 0) {
            Any_var l = member_label ((idx-2) / 3);
            *a = l.in();
        } else if ((idx-2) % 3 == 1) {
            *a <<= member_name ((idx-2) / 3);
        } else {
            TypeCode_var t = member_type ((idx-2) / 3);
            *a <<= t;
        }
        break;

    case tk_value:
        if (idx == 0) {
            *a <<= name();
        } else if (idx == 1) {
            *a <<= type_modifier();
        } else if (idx == 2) {
            CORBA::TypeCode_var t = concrete_base_type();
            if (CORBA::is_nil (t))
                t = new TypeCode (tk_null);
            *a <<= t;
        } else if ((idx-3) % 3 == 0) {
            *a <<= member_name ((idx-3) / 3);
        } else if ((idx-3) % 3 == 1) {
            TypeCode_var t = member_type ((idx-3) / 3);
            *a <<= t;
        } else {
            *a <<= member_visibility ((idx-3) / 3);
        }
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 1374, __PRETTY_FUNCTION__), 0)));
    }
    return a;
}

CORBA::Boolean
CORBA::TypeCode::is_constant () const
{
    return isconst;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::mk_constant ()
{
    isconst = 1;
    return this;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::unalias ()
{
    TypeCode_var t = TypeCode::_duplicate (this);
    while (t->kind() == tk_alias)
        t = t->content_type();

    return t;
}

CORBA::ULong
CORBA::TypeCode::array_size ()
{
    TypeCode_var t = TypeCode::_duplicate (this);
    ((void) ((t->kind() == tk_array) ? 0 : (__assert_fail ("t->kind() == tk_array", "typecode.cc", 1406, __PRETTY_FUNCTION__), 0)));
    ULong size = 1;
    while (t->kind() == tk_array) {
        size *= t->length();
        t = t->content_type();
        t = TypeCode::_duplicate (t->unalias());
    }
    return size;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::array_type ()
{
    TypeCode_var t = TypeCode::_duplicate (this);
    ((void) ((t->kind() == tk_array) ? 0 : (__assert_fail ("t->kind() == tk_array", "typecode.cc", 1420, __PRETTY_FUNCTION__), 0)));
    while (t->kind() == tk_array) {
        t = t->content_type();
        t = TypeCode::_duplicate (t->unalias());
    }
    return TypeCode::_duplicate (t);
}



CORBA::Boolean
CORBA::TypeCode::decode (DataDecoder &dc, MapPosTC *_omap, ULong level)
{
    free ();

    ULong k, buffer_pos;
    CORBA::DataDecoder::EncapsState state;







    MapPosTC *omap = _omap ? _omap : new MapPosTC;





    if (!(dc.enumeration (k))) goto bad;
    tckind = (TCKind)k;

    buffer_pos = dc.buffer()->rpos() - sizeof(CORBA::ULong);
    (*omap)[buffer_pos] = make_pair (level, _nil());

    switch (tckind) {
    case tk_null:
    case tk_void:
    case tk_short:
    case tk_long:
    case tk_longlong:
    case tk_ushort:
    case tk_ulong:
    case tk_ulonglong:
    case tk_float:
    case tk_double:
    case tk_longdouble:
    case tk_boolean:
    case tk_char:
    case tk_wchar:
    case tk_octet:
    case tk_any:
    case tk_TypeCode:
    case tk_Principal:
        break;

    case tk_objref:
    case tk_native:
    case tk_abstract_interface:
    case tk_local_interface:
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        if (!(dc.encaps_end (state))) goto bad;
        break;

    case tk_except:
    case tk_struct: {
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        if (!(dc.get_ulong (k))) goto bad;
        string s;
        for (CORBA::ULong i = 0; i < k; ++i) {
            if (!(dc.get_string_stl (s))) goto bad;
            namevec.push_back (s);
            tcvec.push_back (new TypeCode ());
            if (!(tcvec.back()->decode (dc, omap, level+1))) goto bad;
            tcvec.back()->connect (this);
        }
        if (!(dc.encaps_end (state))) goto bad;
        break;
    }
    case tk_union: {
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        discriminator = new TypeCode ();
        if (!(discriminator->decode (dc, omap, level+1))) goto bad;
        if (!(dc.get_long (defidx))) goto bad;
        if (!(dc.get_ulong (k))) goto bad;
        string s;
        Any *a;
        for (CORBA::ULong i = 0; i < k; ++i) {
            a = new Any;







            if (!(a->demarshal (discriminator, dc))) goto bad;
            if (i == (CORBA::ULong)defidx)
                *a <<= CORBA::Any::from_octet (0);







            labelvec.push_back (a);
            if (!(dc.get_string_stl (s))) goto bad;
            namevec.push_back (s);
            tcvec.push_back (new TypeCode ());
            if (!(tcvec.back()->decode (dc, omap, level+1))) goto bad;
            tcvec.back()->connect (this);
        }
        if (!(dc.encaps_end (state))) goto bad;
        break;
    }
    case tk_enum: {
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        if (!(dc.get_ulong (k))) goto bad;
        string s;
        for (CORBA::ULong i = 0; i < k; ++i) {
            if (!(dc.get_string_stl (s))) goto bad;
            namevec.push_back (s);
        }
        if (!(dc.encaps_end (state))) goto bad;
        break;
    }
    case tk_string:
    case tk_wstring:
        if (!(dc.get_ulong (k))) goto bad;
        len = k;
        break;

    case tk_sequence:
    case tk_array:
        if (!(dc.encaps_begin (state, k))) goto bad;
        content = new TypeCode ();
        if (!(content->decode (dc, omap, level+1))) goto bad;
        content->connect (this);
        if (!(dc.get_ulong (k))) goto bad;
        len = k;
        if (!(dc.encaps_end (state))) goto bad;
        break;

    case tk_alias:
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        content = new TypeCode ();
        if (!(content->decode (dc, omap, level+1))) goto bad;
        content->connect (this);
        if (!(dc.encaps_end (state))) goto bad;
        break;

    case tk_fixed:
        if (!(dc.get_ushort (digits))) goto bad;
        if (!(dc.get_short (scale))) goto bad;
        break;

    case tk_value: {
        len = -1;
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        if (!(dc.get_short (value_mod))) goto bad;
        CORBA::TypeCode_var tmptc = new TypeCode();
        if (!(tmptc->decode (dc, omap, level+1))) goto bad;
        if (tmptc->kind() == tk_null) {
            content = CORBA::TypeCode::_nil();
        } else {
            content = tmptc._retn();
            content->connect (this);
        }
        if (!(dc.get_ulong (k))) goto bad;
        string s;
        CORBA::Visibility vis;
        for (CORBA::ULong i = 0; i < k; ++i) {
            if (!(dc.get_string_stl (s))) goto bad;
            namevec.push_back (s);
            tcvec.push_back (new TypeCode ());
            if (!(tcvec.back()->decode (dc, omap, level+1))) goto bad;
            tcvec.back()->connect (this);
            if (!(dc.get_short (vis))) goto bad;
            visvec.push_back (vis);
        }
        if (!(dc.encaps_end (state))) goto bad;
        break;
    }
    case tk_value_box:
        if (!(dc.encaps_begin (state, k))) goto bad;
        if (!(dc.get_string_stl (repoid))) goto bad;
        if (!(dc.get_string_stl (tcname))) goto bad;
        content = new TypeCode ();
        if (!(content->decode (dc, omap, level+1))) goto bad;
        content->connect (this);
        if (!(dc.encaps_end (state))) goto bad;
        break;

    case ((int)0xffffffff): {
        Long recurse_pos;
        if (!(dc.get_long (recurse_pos))) goto bad;
        Long rpos = dc.buffer()->rpos() - sizeof(CORBA::Long);
        recurse_pos += rpos;



        if (!strcmp (dc.type(), "cdr")) {





            Long alignbase = dc.buffer()->ralign_base() & 3L;
            recurse_pos = alignbase + ((recurse_pos - alignbase + 3) & ~3L);
        }


        ((void) ((recurse_pos >= 0) ? 0 : (__assert_fail ("recurse_pos >= 0", "typecode.cc", 1646, __PRETTY_FUNCTION__), 0)));

        MapPosTC::iterator i = omap->find (recurse_pos);
        ((void) ((i != omap->end()) ? 0 : (__assert_fail ("i != omap->end()", "typecode.cc", 1649, __PRETTY_FUNCTION__), 0)));
        if (CORBA::is_nil ((*i).second.second)) {

            ((void) (((*i).second.first < level) ? 0 : (__assert_fail ("(*i).second.first < level", "typecode.cc", 1652, __PRETTY_FUNCTION__), 0)));
            recurse_depth = level - (*i).second.first - 1;
        } else {

            copy (*(*i).second.second);
        }
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 1661, __PRETTY_FUNCTION__), 0)));
    }

    (*omap)[buffer_pos].second = this;

    if (!_omap)
        delete omap;
    return 1;

bad:
    if (!_omap)
        delete omap;
    free ();
    return 0;
}



void
CORBA::TypeCode::encode (DataEncoder &ec, MapTCPos *_omap) const
{
    MapTCPos *omap = _omap ? _omap : new MapTCPos;

    if (tckind == ((int)0xffffffff)) {
        TypeCode_ptr p = resolve_recursion();
        if (!omap->count (p)) {

            p->encode (ec, omap);
            return;
        }
    }




    ec.enumeration (tckind);






    (*omap)[this] = ec.buffer()->wpos() - sizeof(CORBA::ULong);

    switch (tckind) {
    case tk_null:
    case tk_void:
    case tk_short:
    case tk_long:
    case tk_longlong:
    case tk_ushort:
    case tk_ulong:
    case tk_ulonglong:
    case tk_float:
    case tk_double:
    case tk_longdouble:
    case tk_boolean:
    case tk_char:
    case tk_wchar:
    case tk_octet:
    case tk_any:
    case tk_TypeCode:
    case tk_Principal:
        break;

    case tk_objref:
    case tk_native:
    case tk_abstract_interface:
    case tk_local_interface: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        ec.encaps_end (state);
        break;
    }
    case tk_except:
    case tk_struct: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        ec.put_ulong (namevec.size());
        ((void) ((namevec.size() == tcvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size()", "typecode.cc", 1744, __PRETTY_FUNCTION__), 0)));
        for (mico_vec_size_type i = 0; i < namevec.size(); ++i) {
            ec.put_string (namevec[i]);
            tcvec[i]->encode (ec, omap);
        }
        ec.encaps_end (state);
        break;
    }
    case tk_union: {
        CORBA::Boolean ret;
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        discriminator->encode (ec, omap);
        ec.put_long (defidx);
        ec.put_ulong (namevec.size());
        ((void) ((namevec.size() == tcvec.size() && namevec.size() == labelvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size() && namevec.size() == labelvec.size()", "typecode.cc", 1761, __PRETTY_FUNCTION__), 0)));

        for (mico_vec_size_type i = 0; i < namevec.size(); ++i) {
# 1772 "typecode.cc"
            if ((CORBA::Long)i == defidx) {
                CORBA::Any a;
                a.replace (discriminator);
                ret = a.marshal (ec);
            } else {
                ret = labelvec[i]->marshal (ec);
            }



            ((void) ((ret) ? 0 : (__assert_fail ("ret", "typecode.cc", 1782, __PRETTY_FUNCTION__), 0)));
            ec.put_string (namevec[i]);
            tcvec[i]->encode (ec, omap);
        }
        ec.encaps_end (state);
        break;
    }
    case tk_enum: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        ec.put_ulong (namevec.size());
        for (mico_vec_size_type i = 0; i < namevec.size(); ++i)
            ec.put_string (namevec[i]);
        ec.encaps_end (state);
        break;
    }
    case tk_string:
    case tk_wstring:
        ec.put_ulong (len);
        break;

    case tk_sequence:
    case tk_array: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        content->encode (ec, omap);
        ec.put_ulong (len);
        ec.encaps_end (state);
        break;
    }
    case tk_alias: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        content->encode (ec, omap);
        ec.encaps_end (state);
        break;
    }
    case tk_fixed:
        ec.put_ushort (digits);
        ec.put_short (scale);
        break;

    case tk_value: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        ec.put_short (value_mod);
        if (CORBA::is_nil (content)) {
            ec.enumeration (CORBA::tk_null);
        } else {
            content->encode (ec, omap);
        }
        ec.put_ulong (namevec.size());
        ((void) ((namevec.size() == tcvec.size()) ? 0 : (__assert_fail ("namevec.size() == tcvec.size()", "typecode.cc", 1840, __PRETTY_FUNCTION__), 0)));
        ((void) ((namevec.size() == visvec.size()) ? 0 : (__assert_fail ("namevec.size() == visvec.size()", "typecode.cc", 1841, __PRETTY_FUNCTION__), 0)));
        for (mico_vec_size_type i = 0; i < namevec.size(); ++i) {
            ec.put_string (namevec[i]);
            tcvec[i]->encode (ec, omap);
            ec.put_short (visvec[i]);
        }
        ec.encaps_end (state);
        break;
    }
    case tk_value_box: {
        CORBA::DataEncoder::EncapsState state;
        ec.encaps_begin (state);
        ec.put_string (repoid);
        ec.put_string (tcname);
        content->encode (ec, omap);
        ec.encaps_end (state);
        break;
    }
    case ((int)0xffffffff): {
        TypeCode_ptr p = resolve_recursion();
        MapTCPos::iterator i = omap->find (p);
        ((void) ((i != omap->end()) ? 0 : (__assert_fail ("i != omap->end()", "typecode.cc", 1862, __PRETTY_FUNCTION__), 0)));
        ec.put_long ((*i).second - ec.buffer()->wpos());
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 1867, __PRETTY_FUNCTION__), 0)));
    }
    omap->erase (this);
    if (!_omap)
        delete omap;
}

CORBA::TypeCode_ptr
CORBA::TypeCode::_duplicate (TypeCode_ptr t)
{
    if (!CORBA::is_nil (t)) {
        (t)->_check ();
        if (!t->is_constant())
            t->_ref();
    }
    return t;
}

void
CORBA::release (TypeCode_ptr t)
{
    if (!CORBA::is_nil (t) && t->_check_nothrow() &&
        !t->is_constant() && t->_deref()) {
        delete t;
    }
}

CORBA::Boolean
CORBA::TypeCode::is_recursive_seq ()
{
    if (tckind != tk_sequence || content->tckind != ((int)0xffffffff))
        return 0;
    CORBA::TCKind k = content->resolve_recursion()->unalias()->tckind;
    return (k == tk_struct || k == tk_union);
}
# 1915 "typecode.cc"
CORBA::Boolean
CORBA::TypeCode::is_freestanding()
{
  return this->is_freestanding( 1, this );
}

CORBA::Boolean
CORBA::TypeCode::is_freestanding( CORBA::ULong depth, CORBA::TypeCode_ptr tc )
{
  CORBA::TCKind kindval = tc->kind();
  ((void) ((kindval == CORBA::tk_union || kindval == CORBA::tk_struct) ? 0 : (__assert_fail ("kindval == CORBA::tk_union || kindval == CORBA::tk_struct", "typecode.cc", 1925, __PRETTY_FUNCTION__), 0)));
  for( CORBA::ULong i = 0; i < tc->member_count(); i++ ) {
    CORBA::TypeCode_var mem_tc = tc->member_type( i );
    if( mem_tc->is_recursive_seq() ) {
      if( mem_tc->get_recurse_depth() > depth )
        return false;
    }
    kindval = mem_tc->kind();
    if( kindval == CORBA::tk_union || kindval == CORBA::tk_struct ) {
      CORBA::Boolean res = tc->is_freestanding( ++depth, mem_tc );
      if( !res )
        return false;
    }
  }
  return true;
}

CORBA::ULong
CORBA::TypeCode::get_recurse_depth ()
{
    ((void) ((this->is_recursive_seq() && content->recurse_depth >= 0) ? 0 : (__assert_fail ("this->is_recursive_seq() && content->recurse_depth >= 0", "typecode.cc", 1945, __PRETTY_FUNCTION__), 0)));
    return content->recurse_depth;
}




CORBA::Boolean
CORBA::TypeCode::is_base_type()
{
  CORBA::TypeCode_ptr tc = this->unalias();
  switch( tc->kind() ) {
  case CORBA::tk_boolean:
  case CORBA::tk_char:
  case CORBA::tk_wchar:
  case CORBA::tk_octet:
  case CORBA::tk_ushort:
  case CORBA::tk_ulong:
  case CORBA::tk_short:
  case CORBA::tk_long:
  case CORBA::tk_longlong:
  case CORBA::tk_ulonglong:
  case CORBA::tk_float:
  case CORBA::tk_double:
  case CORBA::tk_longdouble:
  case CORBA::tk_string:
  case CORBA::tk_wstring:
  case CORBA::tk_fixed:
    return 1;
  default:
    break;
  }
  return 0;
}




CORBA::Boolean
CORBA::TypeCode::is_char()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_char;
}




CORBA::Boolean
CORBA::TypeCode::is_wchar()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_wchar;
}




CORBA::Boolean
CORBA::TypeCode::is_bool()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_boolean;
}




CORBA::Boolean
CORBA::TypeCode::is_octet()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_octet;
}




CORBA::Boolean
CORBA::TypeCode::is_enum()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_enum;
}




CORBA::Boolean
CORBA::TypeCode::is_string()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_string;
}




CORBA::Boolean
CORBA::TypeCode::is_wstring()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_wstring;
}




CORBA::Boolean
CORBA::TypeCode::is_any()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_any;
}




CORBA::Boolean
CORBA::TypeCode::is_type_code()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_TypeCode;
}




CORBA::Boolean
CORBA::TypeCode::is_alias()
{
  return this->kind() == CORBA::tk_alias;
}




CORBA::Boolean
CORBA::TypeCode::is_variable()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  if( tc->is_string() || tc->is_wstring() )
    return 1;

  CORBA::TCKind kindval = tc->kind();

  if( kindval == CORBA::tk_any || kindval == CORBA::tk_sequence ||
      kindval == CORBA::tk_objref || kindval == CORBA::tk_TypeCode ||
      kindval == CORBA::tk_native || kindval == CORBA::tk_abstract_interface ||
      kindval == CORBA::tk_local_interface ||
      kindval == CORBA::tk_value || kindval == CORBA::tk_value_box )
    return 1;

  if( kindval == CORBA::tk_struct || kindval == CORBA::tk_union ) {
    for( CORBA::ULong i = 0; i < tc->member_count(); i++ ) {
      CORBA::TypeCode_var tc_member;
      tc_member = tc->member_type( i );
      if( tc_member->is_variable() )
        return 1;
    }
    return 0;
  }
  if( kindval == CORBA::tk_array ) {
    CORBA::TypeCode_var tc_content = tc->content_type();
    if( tc_content->is_variable() )
      return 1;
  }
  return 0;
}




CORBA::Boolean
CORBA::TypeCode::is_objref()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return
    tc->kind() == CORBA::tk_objref ||
    tc->kind() == CORBA::tk_abstract_interface ||
    tc->kind() == CORBA::tk_local_interface;
}




CORBA::Boolean
CORBA::TypeCode::is_object()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  if( tc->kind() == CORBA::tk_objref ) {
    CORBA::String_var nameval = tc->name();
    if( strcmp( nameval, "Object" ) == 0 )
      return true;
  }
  return false;
}




CORBA::Boolean
CORBA::TypeCode::is_sequence()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_sequence;
}




CORBA::Boolean
CORBA::TypeCode::is_array()
{
  CORBA::TypeCode_ptr tc = this->unalias();

  return tc->kind() == CORBA::tk_array;
}

CORBA::Boolean
CORBA::TypeCode::is_valuetype()
{
  CORBA::TypeCode_ptr tc = this->unalias();
  return tc->kind() == CORBA::tk_value || tc->kind() == CORBA::tk_value_box;
}

CORBA::Boolean
CORBA::TypeCode::is_native()
{
  CORBA::TypeCode_ptr tc = this->unalias();
  return tc->kind() == CORBA::tk_native;
}

CORBA::Boolean
CORBA::TypeCode::is_abstract_interface()
{
  CORBA::TypeCode_ptr tc = this->unalias();
  return tc->kind() == CORBA::tk_abstract_interface;
}




CORBA::TypeCodeConst::TypeCodeConst ()
{
# 2212 "typecode.cc"
}

CORBA::TypeCodeConst::TypeCodeConst (const char *s)
    : _tc (0), _str (s)
{
}

CORBA::TypeCodeConst &
CORBA::TypeCodeConst::operator= (const char *s)
{
    if (!_str)
        _str = s;
    return *this;
}

CORBA::TypeCode_ptr
CORBA::TypeCodeConst::operator-> ()
{
    if (!_tc) {
        ((void) ((_str) ? 0 : (__assert_fail ("_str", "typecode.cc", 2231, __PRETTY_FUNCTION__), 0)));
        _tc = (new CORBA::TypeCode (_str))->mk_constant();
    }
    return _tc;
}

CORBA::TypeCodeConst::operator CORBA::TypeCode_ptr ()
{
    if (!_tc) {
        ((void) ((_str) ? 0 : (__assert_fail ("_str", "typecode.cc", 2240, __PRETTY_FUNCTION__), 0)));
        _tc = (new CORBA::TypeCode (_str))->mk_constant();
    }
    return _tc;
}





CORBA::LevelRecord::LevelRecord (Level l, TypeCode_ptr t,
                                 Long _n, Long _i, Long _x)
{
    _level = l;
    _tc = TypeCode::_duplicate (t);
    n = _n;
    i = _i;
    last_i = _i-1;
    x = _x;
}

CORBA::LevelRecord::LevelRecord (const LevelRecord &l)
{
    _level = l._level;
    _tc = TypeCode::_duplicate (l._tc);
    n = l.n;
    i = l.i;
    last_i = l.last_i;
    x = l.x;
}

CORBA::LevelRecord::LevelRecord ()
{
    _level = LNone;
    _tc = _tc_void;
    n = i = x = 0;
    last_i = -1;
}

CORBA::LevelRecord::~LevelRecord ()
{
    CORBA::release (_tc);
}

CORBA::LevelRecord &
CORBA::LevelRecord::operator= (const LevelRecord &l)
{
    if (this != &l) {
        CORBA::release (_tc);
        _level = l._level;
        _tc = TypeCode::_duplicate (l._tc);
        n = l.n;
        i = l.i;
        x = l.x;
        last_i = l.last_i;
    }
    return *this;
}

inline CORBA::LevelRecord::Level
CORBA::LevelRecord::level () const
{
    return _level;
}

inline CORBA::TypeCode_ptr
CORBA::LevelRecord::tc ()
{
    return _tc;
}





CORBA::TypeCodeChecker::TypeCodeChecker ()
{
    done = 1;
    _tc = _tc_void;
    _top = _tc_void;
}

CORBA::TypeCodeChecker::TypeCodeChecker (TypeCode_ptr t)
{
    done = 1;
    _tc = TypeCode::_nil();
    _top = TypeCode::_nil();
    restart (t);
}

CORBA::TypeCodeChecker::TypeCodeChecker (const TypeCodeChecker &tcc)
{

    done = 1;
    _tc = TypeCode::_nil();
    _top = TypeCode::_nil();
    restart (tcc._top);
}

CORBA::TypeCodeChecker &
CORBA::TypeCodeChecker::operator= (const TypeCodeChecker &tcc)
{
    if (this != &tcc) {

        restart (tcc._top);
    }
    return *this;
}

CORBA::TypeCodeChecker::~TypeCodeChecker ()
{
    CORBA::release (_top);
}

inline void
CORBA::TypeCodeChecker::tc (TypeCode_ptr t)
{
    _tc = t->unalias ();
}

inline CORBA::LevelRecord *
CORBA::TypeCodeChecker::level ()
{
    return levelvec.size() > 0 ? &levelvec.back() : 0;
}

CORBA::ULong
CORBA::TypeCodeChecker::level_count () const
{
    return levelvec.size();
}

void
CORBA::TypeCodeChecker::override_tc (TypeCode_ptr t)
{
    if (!CORBA::is_nil (t)) {
        LevelRecord *l = level ();
        if (l) {

            l->last_i = l->i;
        }
        _tc = t->unalias ();
    }
}

CORBA::Boolean
CORBA::TypeCodeChecker::inside (TCKind kind)
{
    LevelRecord *l = level ();
    return l && l->tc()->unalias()->kind() == kind;
}

CORBA::Boolean
CORBA::TypeCodeChecker::level_finished ()
{
    if (done)
        return 1;

    LevelRecord *l = level();
    if (!l) {

        return 0;
    }
    if (l->i >= l->n) {

        return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::TypeCodeChecker::nexttc ()
{
    if (done)
        return 0;

    LevelRecord *l = level();
    if (!l) {

        return 1;
    }
    if (l->i >= l->n) {

        return 0;
    }
    if (l->i == l->last_i) {

        return 1;
    }

    TypeCode_var tv;

    switch (l->level()) {
    case LevelRecord::LArray:
        if (l->i == 0) {



            tv = l->tc()->content_type();

            tc (tv);
        }
        break;

    case LevelRecord::LSequence:
        if (l->i == 0) {
            tv = l->tc()->content_type();
            tc (tv);
        }
        break;

    case LevelRecord::LValueBox:
        tv = l->tc()->content_type();
        tc (tv);
        break;

    case LevelRecord::LStruct:
    case LevelRecord::LExcept:
        tv = l->tc()->member_type (l->i);
        tc (tv);
        break;

    case LevelRecord::LValue:
        tv = l->tc()->member_type_inherited (l->i);
        tc (tv);
        break;

    case LevelRecord::LUnion:
        if (l->i == 0) {
            tv = l->tc()->discriminator_type();
            tc (tv);
        } else if (l->x >= 0) {
            tv = l->tc()->member_type (l->x);
            tc (tv);
        }
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "typecode.cc", 2478, __PRETTY_FUNCTION__), 0)));
    }
    l->last_i = l->i;
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::advance ()
{
    if (done)
        return 0;

    LevelRecord *l = level();
    if (!l) {

        return 1;
    }
    if (l->i >= l->n) {

        return 0;
    }
    l->i += 1;
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::leave (LevelRecord::Level lev, Boolean sloppy)
{
    LevelRecord *l = level ();
    if (!l || l->level() != lev)
        return 0;
    if (!sloppy && l->i != l->n)
        return 0;
    tc (l->tc());
    levelvec.erase (levelvec.end() - 1);
    if (levelvec.size() == 0)
        done = 1;
    return 1;
}

inline void
CORBA::TypeCodeChecker::enter (const LevelRecord &rec)
{
    levelvec.push_back (rec);
}

CORBA::TypeCode_ptr
CORBA::TypeCodeChecker::tc ()
{
    nexttc ();
    return done ? _tc_void : _tc;
}

CORBA::Boolean
CORBA::TypeCodeChecker::basic (TypeCode_ptr t)
{
    if (!nexttc())
        return 0;
    if (!_tc->equivalent (t->unalias())) {
        return 0;
    }
    advance ();
    if (!level())
        done = 1;
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::abstract_interface (TypeCode_ptr override)
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_abstract_interface)
        return 0;
    override_tc (override);
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::enumeration (Long val)
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_enum || val >= (Long)_tc->member_count())
        return 0;
    advance ();
    if (!level())
        done = 1;
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::union_begin ()
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_union)
        return 0;
    advance ();
    enter (LevelRecord (LevelRecord::LUnion, _tc, 1));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::union_selection (Long sel_idx)
{
    LevelRecord *l = level ();
    if (!l || l->level() != LevelRecord::LUnion || l->i > 1)
        return 0;
    if (sel_idx >= 0 && sel_idx >= (Long)l->tc()->member_count())
        return 0;
    l->n = sel_idx < 0 ? 1 : 2;
    l->x = sel_idx;
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::union_end (Boolean sloppy)
{
    return leave (LevelRecord::LUnion, sloppy);
}

CORBA::Boolean
CORBA::TypeCodeChecker::struct_begin ()
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_struct)
        return 0;
    advance ();
    enter (LevelRecord (LevelRecord::LStruct, _tc, _tc->member_count()));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::struct_end (Boolean sloppy)
{
    return leave (LevelRecord::LStruct, sloppy);
}

CORBA::Boolean
CORBA::TypeCodeChecker::except_begin ()
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_except)
        return 0;
    advance ();
    enter (LevelRecord (LevelRecord::LExcept, _tc, _tc->member_count()));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::except_end (Boolean sloppy)
{
    return leave (LevelRecord::LExcept, sloppy);
}

CORBA::Boolean
CORBA::TypeCodeChecker::seq_begin (ULong len)
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_sequence ||
        (_tc->length() > 0 && len > _tc->length()))
        return 0;
    advance ();
    enter (LevelRecord (LevelRecord::LSequence, _tc, len));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::seq_end (Boolean sloppy)
{
    return leave (LevelRecord::LSequence, sloppy);
}

CORBA::Boolean
CORBA::TypeCodeChecker::arr_begin ()
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_array)
        return 0;
    advance ();



    enter (LevelRecord (LevelRecord::LArray, _tc, _tc->length()));

    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::arr_end (Boolean sloppy)
{
    return leave (LevelRecord::LArray, sloppy);
}

CORBA::Boolean
CORBA::TypeCodeChecker::value_begin (TypeCode_ptr override)
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_value)
        return 0;
    override_tc (override);
    advance ();
    enter (LevelRecord (LevelRecord::LValue, _tc,
                        _tc->member_count_inherited()));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::value_end ()
{
    return leave (LevelRecord::LValue, 1);
}

CORBA::Boolean
CORBA::TypeCodeChecker::valuebox_begin ()
{
    if (!nexttc())
        return 0;
    if (_tc->kind() != tk_value_box)
        return 0;
    advance ();
    enter (LevelRecord (LevelRecord::LValueBox, _tc, 1));
    return 1;
}

CORBA::Boolean
CORBA::TypeCodeChecker::valuebox_end ()
{
    return leave (LevelRecord::LValueBox);
}

CORBA::Boolean
CORBA::TypeCodeChecker::completed () const
{
    return done;
}

void
CORBA::TypeCodeChecker::finish ()
{
    levelvec.erase (levelvec.begin(), levelvec.end());
    done = 1;
    tc (_top);
}

void
CORBA::TypeCodeChecker::restart ()
{
    levelvec.erase (levelvec.begin(), levelvec.end());
    done = 1;
    CORBA::release (_top);
    _top = _tc_void;
    tc (_top);
}

void
CORBA::TypeCodeChecker::restart (TypeCode_ptr t)
{
    levelvec.erase (levelvec.begin(), levelvec.end());
    done = 0;
    CORBA::release (_top);
    _top = TypeCode::_duplicate (t);
    tc (_top);
}





static struct InitTypeCodeConstants {
    InitTypeCodeConstants ()
    {
    CORBA::_tc_null =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_null)->mk_constant();

        CORBA::_tc_void =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_void)->mk_constant();

        CORBA::_tc_short =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_short)->mk_constant();

        CORBA::_tc_long =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_long)->mk_constant();

        CORBA::_tc_longlong =
            CORBA::TypeCode::create_basic_tc(
                CORBA::tk_longlong)->mk_constant();

        CORBA::_tc_ushort =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_ushort)->mk_constant();

        CORBA::_tc_ulong =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_ulong)->mk_constant();

        CORBA::_tc_ulonglong =
            CORBA::TypeCode::create_basic_tc(
                CORBA::tk_ulonglong)->mk_constant();

        CORBA::_tc_float =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_float)->mk_constant();

        CORBA::_tc_double =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_double)->mk_constant();

        CORBA::_tc_longdouble =
            CORBA::TypeCode::create_basic_tc(
                CORBA::tk_longdouble)->mk_constant();

        CORBA::_tc_boolean =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_boolean)->mk_constant();

        CORBA::_tc_char =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_char)->mk_constant();

        CORBA::_tc_wchar =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_wchar)->mk_constant();

        CORBA::_tc_octet =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_octet)->mk_constant();

        CORBA::_tc_any =
            CORBA::TypeCode::create_basic_tc(CORBA::tk_any)->mk_constant();

        CORBA::_tc_TypeCode =
            CORBA::TypeCode::create_basic_tc(
                CORBA::tk_TypeCode)->mk_constant();

        CORBA::_tc_Principal =
            CORBA::TypeCode::create_basic_tc(
                CORBA::tk_Principal)->mk_constant();

        CORBA::_tc_Object =
            CORBA::TypeCode::create_interface_tc(
                "IDL:omg.org/CORBA/Object:1.0",
                "Object")->mk_constant();

        CORBA::_tc_ValueBase =
            CORBA::TypeCode::create_value_tc(
                "IDL:omg.org/CORBA/ValueBase:1.0",
                "ValueBase",
                CORBA::VM_NONE,
                CORBA::TypeCode::_nil(),
                CORBA::ValueMemberSeq())->mk_constant();

        CORBA::_tc_string =
            CORBA::TypeCode::create_string_tc(0)->mk_constant();

        CORBA::_tc_wstring =
            CORBA::TypeCode::create_wstring_tc(0)->mk_constant();


        CORBA::_tc_Context =
            CORBA::TypeCode::create_sequence_tc(
                0, CORBA::_tc_string)->mk_constant();

        CORBA::_tc_AbstractBase =
            CORBA::TypeCode::create_abstract_interface_tc(
                "IDL:omg.org/CORBA/AbstractBase:1.0",
                "AbstractBase")->mk_constant();

        {
            CORBA::StructMemberSeq ss;
            ss.length (4);

            ss[0].name = (const char *)"name";
            ss[0].type = CORBA::_tc_string;
            ss[0].type_def = 0;

            ss[1].name = (const char *)"argument";
            ss[1].type = CORBA::_tc_any;
            ss[1].type_def = 0;

            ss[2].name = (const char *)"len";
            ss[2].type = CORBA::_tc_long;
            ss[2].type_def = 0;

            ss[3].name = (const char *)"arg_modes";
            ss[3].type = CORBA::_tc_ulong;
            ss[3].type_def = 0;

            CORBA::_tc_NamedValue = CORBA::TypeCode::create_struct_tc (
                "IDL:omg.org/CORBA/NamedValue:1.0",
                "NamedValue",
                ss)->mk_constant();
        }

        CORBA::TypeCode_ptr _tc_CompletionStatus;
        {
            CORBA::EnumMemberSeq es;
            es.length (3);
            es[0] = CORBA::string_dup ("COMPLETED_YES");
            es[1] = CORBA::string_dup ("COMPLETED_NO");
            es[2] = CORBA::string_dup ("COMPLETED_MAYBE");

            _tc_CompletionStatus = CORBA::TypeCode::create_enum_tc (
                "IDL:omg.org/CORBA/CompletionStatus:1.0",
                "CompletionStatus",
                es)->mk_constant();
        }
# 2903 "typecode.cc"
# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_UNKNOWN = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "UNKNOWN" ":1.0", "UNKNOWN", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_BAD_PARAM = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "BAD_PARAM" ":1.0", "BAD_PARAM", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_NO_MEMORY = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "NO_MEMORY" ":1.0", "NO_MEMORY", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_IMP_LIMIT = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "IMP_LIMIT" ":1.0", "IMP_LIMIT", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_COMM_FAILURE = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "COMM_FAILURE" ":1.0", "COMM_FAILURE", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INV_OBJREF = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INV_OBJREF" ":1.0", "INV_OBJREF", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_NO_PERMISSION = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "NO_PERMISSION" ":1.0", "NO_PERMISSION", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INTERNAL = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INTERNAL" ":1.0", "INTERNAL", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_MARSHAL = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "MARSHAL" ":1.0", "MARSHAL", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INITIALIZE = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INITIALIZE" ":1.0", "INITIALIZE", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_NO_IMPLEMENT = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "NO_IMPLEMENT" ":1.0", "NO_IMPLEMENT", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_BAD_TYPECODE = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "BAD_TYPECODE" ":1.0", "BAD_TYPECODE", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_BAD_OPERATION = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "BAD_OPERATION" ":1.0", "BAD_OPERATION", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_NO_RESOURCES = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "NO_RESOURCES" ":1.0", "NO_RESOURCES", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_NO_RESPONSE = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "NO_RESPONSE" ":1.0", "NO_RESPONSE", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_PERSIST_STORE = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "PERSIST_STORE" ":1.0", "PERSIST_STORE", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_BAD_INV_ORDER = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "BAD_INV_ORDER" ":1.0", "BAD_INV_ORDER", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_TRANSIENT = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "TRANSIENT" ":1.0", "TRANSIENT", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_FREE_MEM = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "FREE_MEM" ":1.0", "FREE_MEM", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INV_IDENT = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INV_IDENT" ":1.0", "INV_IDENT", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INV_FLAG = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INV_FLAG" ":1.0", "INV_FLAG", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INTF_REPOS = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INTF_REPOS" ":1.0", "INTF_REPOS", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_BAD_CONTEXT = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "BAD_CONTEXT" ":1.0", "BAD_CONTEXT", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_OBJ_ADAPTER = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "OBJ_ADAPTER" ":1.0", "OBJ_ADAPTER", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_DATA_CONVERSION = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "DATA_CONVERSION" ":1.0", "DATA_CONVERSION", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_OBJECT_NOT_EXIST = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "OBJECT_NOT_EXIST" ":1.0", "OBJECT_NOT_EXIST", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_TRANSACTION_REQUIRED = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "TRANSACTION_REQUIRED" ":1.0", "TRANSACTION_REQUIRED", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_TRANSACTION_ROLLEDBACK = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "TRANSACTION_ROLLEDBACK" ":1.0", "TRANSACTION_ROLLEDBACK", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INVALID_TRANSACTION = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INVALID_TRANSACTION" ":1.0", "INVALID_TRANSACTION", ss)->mk_constant(); }
{ CORBA::StructMemberSeq ss; ss.length (2); ss[0].name = (const char *)"minor"; ss[0].type = CORBA::_tc_ulong; ss[0].type_def = 0; ss[1].name = (const char *)"completed"; ss[1].type = _tc_CompletionStatus; ss[1].type_def = 0; CORBA::_tc_INV_POLICY = CORBA::TypeCode::create_exception_tc ( "IDL:omg.org/CORBA/" "INV_POLICY" ":1.0", "INV_POLICY", ss)->mk_constant(); }
# 2904 "typecode.cc" 2


    }
} __init_tc_constants;


namespace CORBA {
    CORBA::TypeCode_ptr _tc_null;
    CORBA::TypeCode_ptr _tc_void;
    CORBA::TypeCode_ptr _tc_short;
    CORBA::TypeCode_ptr _tc_long;
    CORBA::TypeCode_ptr _tc_longlong;
    CORBA::TypeCode_ptr _tc_ushort;
    CORBA::TypeCode_ptr _tc_ulong;
    CORBA::TypeCode_ptr _tc_ulonglong;
    CORBA::TypeCode_ptr _tc_float;
    CORBA::TypeCode_ptr _tc_double;
    CORBA::TypeCode_ptr _tc_longdouble;
    CORBA::TypeCode_ptr _tc_boolean;
    CORBA::TypeCode_ptr _tc_char;
    CORBA::TypeCode_ptr _tc_wchar;
    CORBA::TypeCode_ptr _tc_octet;
    CORBA::TypeCode_ptr _tc_any;
    CORBA::TypeCode_ptr _tc_TypeCode;
    CORBA::TypeCode_ptr _tc_Principal;
    CORBA::TypeCode_ptr _tc_Object;
    CORBA::TypeCode_ptr _tc_ValueBase;
    CORBA::TypeCode_ptr _tc_AbstractBase;
    CORBA::TypeCode_ptr _tc_string;
    CORBA::TypeCode_ptr _tc_wstring;
    CORBA::TypeCode_ptr _tc_Context;
    CORBA::TypeCode_ptr _tc_NamedValue;


# 1 "../include/mico/sysexc.h" 1
# 24 "../include/mico/sysexc.h"
CORBA::TypeCode_ptr _tc_UNKNOWN;
CORBA::TypeCode_ptr _tc_BAD_PARAM;
CORBA::TypeCode_ptr _tc_NO_MEMORY;
CORBA::TypeCode_ptr _tc_IMP_LIMIT;
CORBA::TypeCode_ptr _tc_COMM_FAILURE;
CORBA::TypeCode_ptr _tc_INV_OBJREF;
CORBA::TypeCode_ptr _tc_NO_PERMISSION;
CORBA::TypeCode_ptr _tc_INTERNAL;
CORBA::TypeCode_ptr _tc_MARSHAL;
CORBA::TypeCode_ptr _tc_INITIALIZE;
CORBA::TypeCode_ptr _tc_NO_IMPLEMENT;
CORBA::TypeCode_ptr _tc_BAD_TYPECODE;
CORBA::TypeCode_ptr _tc_BAD_OPERATION;
CORBA::TypeCode_ptr _tc_NO_RESOURCES;
CORBA::TypeCode_ptr _tc_NO_RESPONSE;
CORBA::TypeCode_ptr _tc_PERSIST_STORE;
CORBA::TypeCode_ptr _tc_BAD_INV_ORDER;
CORBA::TypeCode_ptr _tc_TRANSIENT;
CORBA::TypeCode_ptr _tc_FREE_MEM;
CORBA::TypeCode_ptr _tc_INV_IDENT;
CORBA::TypeCode_ptr _tc_INV_FLAG;
CORBA::TypeCode_ptr _tc_INTF_REPOS;
CORBA::TypeCode_ptr _tc_BAD_CONTEXT;
CORBA::TypeCode_ptr _tc_OBJ_ADAPTER;
CORBA::TypeCode_ptr _tc_DATA_CONVERSION;
CORBA::TypeCode_ptr _tc_OBJECT_NOT_EXIST;
CORBA::TypeCode_ptr _tc_TRANSACTION_REQUIRED;
CORBA::TypeCode_ptr _tc_TRANSACTION_ROLLEDBACK;
CORBA::TypeCode_ptr _tc_INVALID_TRANSACTION;
CORBA::TypeCode_ptr _tc_INV_POLICY;
# 2939 "typecode.cc" 2


};
# 22 "orb_all.cc" 2
# 1 "util.cc" 1
# 25 "util.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "util.cc" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 27 "util.cc" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 28 "util.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 29 "util.cc" 2
# 1 "/usr/include/errno.h" 1 3 4
# 30 "util.cc" 2
# 1 "/opt/gcc3/include/g++-v3/algorithm" 1 3
# 31 "util.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 32 "util.cc" 2
# 1 "/opt/gcc3/include/g++-v3/fstream.h" 1 3
# 33 "util.cc" 2
# 1 "/opt/gcc3/include/g++-v3/strstream.h" 1 3
# 34 "util.cc" 2
# 1 "../include/mico/impl.h" 1
# 35 "util.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 36 "util.cc" 2
# 1 "../include/mico/util.h" 1
# 37 "util.cc" 2
# 1 "../include/mico/os-misc.h" 1
# 38 "util.cc" 2
# 1 "../include/mico/os-math.h" 1
# 39 "util.cc" 2







void
mico_assert (const char *file, int line)
{
    cout << file << ":" << line << ": assertion failed" << endl;



    abort ();
}
# 75 "util.cc"
string
xstrerror (int err)
{
    char *cp = strerror (err);

    if (cp)
        return string(cp);


    string lasterr;
    lasterr = "error ";
    lasterr += xdec ((*__errno_location ()));
    return lasterr;
}

string
xdec (int i)
{
    ostrstream ostr;
    ostr << i << ends;

    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

string
xdec (long i)
{
    ostrstream ostr;
    ostr << i << ends;

    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

string
xdec (OSMisc::longlong i)
{
    ostrstream ostr;



    ostr << i << ends;


    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

string
xdec (unsigned int i)
{
    ostrstream ostr;
    ostr << i << ends;

    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

string
xdec (unsigned long i)
{
    ostrstream ostr;
    ostr << i << ends;

    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

string
xdec (OSMisc::ulonglong i)
{
    ostrstream ostr;




    ostr << i << ends;


    string s = ostr.str();
    ostr.rdbuf()->freeze (0);
    return s;
}

size_t
xwcslen (const wchar_t *s)
{
    size_t len = 0;
    while (*s++)
        ++len;
    return len;
}

int
xwcscmp (const wchar_t *s1, const wchar_t *s2)
{
    while (*s1 && *s1 == *s2) {
        ++s1; ++s2;
    }
    if (*s1 == *s2)
        return 0;
    if (*s1 < *s2)
        return -1;
    return 1;
}

wchar_t *
xwcscpy (wchar_t *_d, const wchar_t *s)
{
    wchar_t *d = _d;

    while ((*d++ = *s++))
        ;
    return _d;
}

wchar_t *
xwcsncpy (wchar_t *_d, const wchar_t *s, size_t n)
{
    wchar_t *d = _d;

    int i = (int)n;
    while (--i >= 0 && (*d++ = *s++))
        ;
    return _d;
}

char *
mico_url_encode (const CORBA::Octet * ptr, CORBA::ULong len)
{
  string res;

  for (CORBA::ULong i=0; i<len; i++) {

    if ((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z') ||
        (*ptr >= '0' && *ptr <= '9')) {
      res += *ptr++;
      continue;
    }

    switch (*ptr) {
    case ';':
    case '/':
    case ':':
    case '?':
    case '@':
    case '&':
    case '=':
    case '+':
    case '$':
    case ',':
    case '-':
    case '.':
    case '!':
    case '~':
    case '*':
    case '\'':
    case '(':
    case ')':
      res += *ptr++;
      break;

    default:
      {
        CORBA::Octet x = *ptr++;
        res += '%';
        res += (char) mico_to_xdigit (x>>4);
        res += (char) mico_to_xdigit (x&15);
      }
    }
  }

  return CORBA::string_dup (res.c_str());
}

CORBA::Octet *
mico_url_decode (const char * ptr, CORBA::ULong & len)
{
  CORBA::Octet * str = (CORBA::Octet *) CORBA::string_alloc (strlen (ptr));
  CORBA::Octet * res = str;

  len = 0;

  while (*ptr) {
    if (*ptr == '%') {
      if ((ptr[1] < '0' || ptr[1] > '9') && (ptr[1] < 'a' || ptr[1] > 'f') ||
          (ptr[2] < '0' || ptr[2] > '9') && (ptr[2] < 'a' || ptr[2] > 'f')) {
        CORBA::string_free ((char *) str);
        return __null;
      }
      *res = (char) (mico_from_xdigit(ptr[1])<<4 | mico_from_xdigit(ptr[2]));
      ptr += 3;
    }
    else {
      *res = *ptr++;
    }
    res++;
    len++;
  }

  return str;
}

CORBA::ULong
mico_string_hash (const char *s, CORBA::ULong max)
{
    if (max == 0)
        return 0;

    CORBA::ULong g, v = 0;
    while (*s) {
        v = (v << 4) + *s++;
        if ((g = v & 0xf0000000)) {
            v = v ^ (g >> 24);
            v = v ^ g;
        }
    }
    return v % max;
}





CORBA::InterfaceDispatcher::~InterfaceDispatcher ()
{
}

CORBA::MethodDispatcher::~MethodDispatcher ()
{
    for (mico_vec_size_type i = 0; i < _dispatcher.size(); ++i)
        delete _dispatcher[i];
}

void
CORBA::MethodDispatcher::register_dispatcher (InterfaceDispatcher *disp)
{
    _dispatcher.push_back (disp);
}

void
CORBA::MethodDispatcher::invoke (CORBA::ServerRequest_ptr _req,
                                 CORBA::Environment &_env)
{
    for (mico_vec_size_type i=0; i < _dispatcher.size(); ++i) {
        if (_dispatcher[i]->dispatch (_req, _env))
            return;
    }
    _req->exception (new BAD_OPERATION);
}





CORBA::StaticInterfaceDispatcher::~StaticInterfaceDispatcher ()
{
}

CORBA::StaticMethodDispatcher::~StaticMethodDispatcher ()
{
    for (mico_vec_size_type i = 0; i < _dispatcher.size(); ++i)
        delete _dispatcher[i];
}

void
CORBA::StaticMethodDispatcher::
                    register_dispatcher (StaticInterfaceDispatcher *disp)
{
    _dispatcher.push_back (disp);
}

void
CORBA::StaticMethodDispatcher::invoke (CORBA::StaticServerRequest_ptr _req,
                                       CORBA::Environment &_env)
{
    for (mico_vec_size_type i=0; i < _dispatcher.size(); ++i) {
        if (_dispatcher[i]->dispatch (_req, _env))
            return;
    }
    _req->set_exception (new BAD_OPERATION);
    _req->write_results();
}





MICO::Logger * MICO::Logger::_instance = 0;
ostream ** MICO::Logger::_out = 0;

MICO::Logger::Logger ()
{
  ((void) ((!_instance) ? 0 : (__assert_fail ("!_instance", "util.cc", 374, __PRETTY_FUNCTION__), 0)));
  _instance = this;

  _out = new ostream * [All];

  for (int i=0; i<All; i++) {
    _out[i] = 0;
  }

  Log (Error);
}

MICO::Logger::~Logger ()
{
  _instance = 0;

  for (int i=0; i<All; i++) {
    if (_out[i] != &cout && _out[i] != &cerr) {
      delete _out[i];
    }
  }

  delete [] _out;
}

void
MICO::Logger::Log (MessageType msg, CORBA::Boolean onoff,
                   const char * file)
{
  if (!_instance) {
    new Logger;
    ((void) ((_instance) ? 0 : (__assert_fail ("_instance", "util.cc", 405, __PRETTY_FUNCTION__), 0)));
  }

  if (msg == All) {
    for (int i=0; i<All; i++) {
      Log ((MessageType) i, onoff, file);
    }
    return;
  }

  if (_out[msg] != &cout && _out[msg] != &cerr) {
    delete _out[msg];
  }

  if (onoff) {
    if (file) {
      _out[msg] = new ofstream (file, ios::app);
    }
    else {
      _out[msg] = &cerr;
    }
  }
  else {
    _out[msg] = 0;
  }
}

void
MICO::Logger::Log (const char * msg, CORBA::Boolean onoff,
                   const char * file)
{
  if (strcmp (msg, "Info") == 0) {
    Log (Info, onoff, file);
  }
  else if (strcmp (msg, "Warning") == 0) {
    Log (Warning, onoff, file);
  }
  else if (strcmp (msg, "Error") == 0) {
    Log (Error, onoff, file);
  }
  else if (strcmp (msg, "GIOP") == 0) {
    Log (GIOP, onoff, file);
  }
  else if (strcmp (msg, "IIOP") == 0) {
    Log (IIOP, onoff, file);
  }
  else if (strcmp (msg, "Transport") == 0) {
    Log (Transport, onoff, file);
  }
  else if (strcmp (msg, "All") == 0) {
    Log (All, onoff, file);
  }
  else {
    if (IsLogged (Warning)) {
      Stream (Warning)
        << "Warning: No such debug level" << msg << " is available." << endl;
    }
  }
}

CORBA::Boolean
MICO::Logger::IsLogged (MessageType msg)
{
  if (!_instance) {
    return 0;
  }
  return (_out[msg] != 0);
}

ostream &
MICO::Logger::Stream (MessageType msg)
{
  ((void) ((_instance) ? 0 : (__assert_fail ("_instance", "util.cc", 477, __PRETTY_FUNCTION__), 0)));
  ((void) ((_out[msg]) ? 0 : (__assert_fail ("_out[msg]", "util.cc", 478, __PRETTY_FUNCTION__), 0)));
  return *_out[msg];
}





MICOGetOpt::MICOGetOpt (const OptMap &opts)
    : _in_opts (opts)
{
}

MICOGetOpt::~MICOGetOpt ()
{
}

CORBA::Boolean
MICOGetOpt::parse (int &argc, char *argv[], CORBA::Boolean ignore)
{
    vector<int> erase;
    vector<string> args;

    int i;
    for (i = 1; i < argc; ++i)
        args.push_back (argv[i]);
    if (!parse (args, erase, ignore))
        return 0;

    int nargc = 0;
    for (i = 0; i < argc; ++i) {
        if (erase.size() > 0 && i == erase[0]+1) {
            erase.erase (erase.begin());
        } else {
            argv[nargc++] = argv[i];
        }
    }
    if (nargc < argc)
        argv[nargc] = 0;
    argc = nargc;

    return 1;
}

CORBA::Boolean
MICOGetOpt::parse (const vector<string> &argv, vector<int> &erase,
                   CORBA::Boolean ignore)
{
    for (mico_vec_size_type i = 0; i < argv.size(); ++i) {
        string arg = argv[i];
        if (arg == "--") {
            erase.push_back (i);
            break;
        }
        if (!ignore && (arg.size() == 0 || arg[0] != '-')) {
            break;
        }
        OptMap::const_iterator it = _in_opts.find (arg);
        if (it == _in_opts.end()) {
            int pos = 0;
            if (arg.length() > 2) {

                arg = arg.substr (0, 2);
                pos = 2;
                it = _in_opts.find (arg);
            }
            if (it == _in_opts.end() && (pos = argv[i].find ("=")) > 0) {

                arg = argv[i].substr (0, pos);
                ++pos;
                it = _in_opts.find (arg);
            }
            if (it != _in_opts.end()) {
                if ((*it).second.length() == 0) {
                    cerr << "unexpected argument for option " << arg << endl;
                    return 0;
                }
                _out_opts.push_back (make_pair (arg, argv[i].substr (pos)));
                erase.push_back (i);
            } else if (!ignore) {
                cerr << "unknown option: " << argv[i] << endl;
                return 0;
            }
        } else {
            erase.push_back (i);
            if ((*it).second.length() > 0) {


                if (++i == argv.size()) {
                    cerr << "missing argument for option " << arg << endl;
                    return 0;
                }
                _out_opts.push_back (make_pair (arg, argv[i]));
                erase.push_back (i);
            } else {


                _out_opts.push_back (make_pair (arg, string("")));
            }
        }
    }
    return 1;
}

CORBA::Boolean
MICOGetOpt::parse (const vector<string> &argv, CORBA::Boolean ignore)
{
    vector<int> erase;
    return parse (argv, erase, ignore);
}

CORBA::Boolean
MICOGetOpt::parse (const string &_filename, CORBA::Boolean ignore)
{
    string fn = _filename;

    if (fn[0] == '~') {
        char *s = getenv ("HOME");
        if (!s) {
            return 1;
        }
        string home = s;
        fn.replace (0, 1, home);
    }
    ifstream in (fn.c_str());
    if (!in)
        return 1;

    char line[10000], *lptr, *tok;
    vector<string> argv;

    while (42) {
        if (in.getline(line, sizeof(line)).eof())
            break;
        if (!line[0])
            continue;
        lptr = line;
        while ((tok = ::strtok (lptr, " \t"))) {
            if (lptr && *tok == '#')
                break;
            argv.push_back (tok);
            lptr = 0;
        }
    }
    return parse (argv, ignore);
}

const MICOGetOpt::OptVec &
MICOGetOpt::opts () const
{
    return _out_opts;
}





CORBA::Boolean
mico_fnmatch (const char *s, const char *p)
{
    register int scc;
    int ok, lc;
    int c, cc;

    for (;;) {
        scc = *s++ & 0177;
        switch ((c = *p++)) {
        case '[':
            ok = 0;
            lc = 077777;
            while ((cc = *p++)) {
                if (cc == ']') {
                    if (ok)
                        break;
                    return 0;
                }
                if (cc == '-') {
                    if (lc <= scc && scc <= *p++)
                        ok++;
                } else
                    if (scc == (lc = cc))
                        ok++;
            }
            if (cc == 0)
                if (ok)
                    p--;
                else
                    return 0;
            continue;

        case '*':
            if (!*p)
                return 1;
            s--;
            do {
                if (mico_fnmatch(s, p))
                    return 1;
            } while (*s++);
            return 0;

        case 0:
            return (scc == 0);

        default:
            if (c != scc)
                return 0;
            continue;

        case '?':
            if (scc == 0)
                return 0;
            continue;
        }
    }
}





MICO::Process::~Process ()
{
}

MICO::ProcessCallback::~ProcessCallback ()
{
}





CORBA::Boolean
MICO::SharedLib::init ()
{





    CORBA::Boolean (*initfn) (const char *) =
        (CORBA::Boolean (*) (const char *))symbol ("mico_module_init");
    if (!initfn)
        return 0;
    return (*initfn) ("2.3.5");
}

void
MICO::SharedLib::exit ()
{
    void (*exitfn) () = (void (*) ())symbol ("mico_module_exit");
    if (exitfn)
        (*exitfn) ();





}

MICO::SharedLib::~SharedLib ()
{
}





struct IeeeLDouble {
# 755 "util.cc"
    unsigned int f4 : 32;
    unsigned int f3 : 32;
    unsigned int f2 : 32;
    unsigned int f1 : 16;
    unsigned int e : 15;
    unsigned int s : 1;

};
# 773 "util.cc"
struct IeeeDouble {






    unsigned int f2 : 32;
    unsigned int f1 : 20;
    unsigned int e : 11;
    unsigned int s : 1;

};
# 795 "util.cc"
struct IeeeFloat {





    unsigned int f : 23;
    unsigned int e : 8;
    unsigned int s : 1;

};
# 814 "util.cc"
void
mico_ieee2ldouble (CORBA::Octet ieee[16], CORBA::LongDouble &d)
{
    IeeeLDouble &ie = (IeeeLDouble &)*ieee;

    if (ie.e == 0) {
        if (ie.f1 == 0 && ie.f2 == 0 && ie.f3 == 0 && ie.f4 == 0) {

            d = 0.0;
        } else {

            d = ldexpl ((long double)ie.f1, -16 + (1 - 16384));
            d += ldexpl ((long double)ie.f2, -(16 +32) + (1 - 16384));
            d += ldexpl ((long double)ie.f3, -((16 +32)+32) + (1 - 16384));
            d += ldexpl ((long double)ie.f4, -(((16 +32)+32)+32) + (1 - 16384));
            if (ie.s)
                d = -d;
        }
    } else if (ie.e == ((1L << 15) - 1 - 16384) + 16384) {
        if (ie.f1 == 0 && ie.f2 == 0 && ie.f3 == 0 && ie.f4 == 0) {

            d = OSMath::infinityl (ie.s);
        } else {

            d = OSMath::nanl ();
        }
    } else {

        d = ldexpl (ldexpl ((long double)ie.f1, -16) +
                    ldexpl ((long double)ie.f2, -(16 +32)) +
                    ldexpl ((long double)ie.f3, -((16 +32)+32)) +
                    ldexpl ((long double)ie.f4, -(((16 +32)+32)+32)) +
                    1.0,
                    ie.e - 16384);
        if (ie.s)
            d = -d;
    }
}

void
mico_ldouble2ieee (CORBA::Octet ieee[16], CORBA::LongDouble d)
{
    IeeeLDouble &ie = (IeeeLDouble &)*ieee;

    if (OSMath::is_nanl (d)) {

        ie.s = 0;
        ie.e = ((1L << 15) - 1 - 16384) + 16384;
        ie.f1 = 1;
        ie.f2 = 1;
        ie.f3 = 1;
        ie.f4 = 1;
    } else if (OSMath::is_infinityl (d)) {

        ie.s = (d < 0);
        ie.e = ((1L << 15) - 1 - 16384) + 16384;
        ie.f1 = 0;
        ie.f2 = 0;
        ie.f3 = 0;
        ie.f4 = 0;
    } else if (d == 0.0) {

        ie.s = 0;
        ie.e = 0;
        ie.f1 = 0;
        ie.f2 = 0;
        ie.f3 = 0;
        ie.f4 = 0;
    } else {

        int exp;
        long double frac = frexpl (fabsl (d), &exp);

        while (frac < 1.0 && exp >= (1 - 16384)) {
            frac = ldexpl (frac, 1);
            --exp;
        }
        if (exp < (1 - 16384)) {

            frac = ldexpl (frac, exp - (1 - 16384));
            exp = 0;
        } else {

            ((void) ((1.0 <= frac && frac < 2.0) ? 0 : (__assert_fail ("1.0 <= frac && frac < 2.0", "util.cc", 897, __PRETTY_FUNCTION__), 0)));
            ((void) (((1 - 16384) <= exp && exp <= ((1L << 15) - 1 - 16384)) ? 0 : (__assert_fail ("(1 - 16384) <= exp && exp <= ((1L << 15) - 1 - 16384)", "util.cc", 898, __PRETTY_FUNCTION__), 0)));

            exp += 16384;
            frac -= 1.0;
        }
        ie.s = (d < 0);
        ie.e = exp;
        ie.f1 = (unsigned long)ldexpl (frac, 16);
        ie.f2 = (unsigned long)ldexpl (frac, (16 +32));
        ie.f3 = (unsigned long)ldexpl (frac, ((16 +32)+32));
        ie.f4 = (unsigned long)ldexpl (frac, (((16 +32)+32)+32));
    }
}

void
mico_ieee2double (CORBA::Octet ieee[8], CORBA::Double &d)
{
    IeeeDouble &ie = (IeeeDouble &)*ieee;

    if (ie.e == 0) {
        if (ie.f1 == 0 && ie.f2 == 0) {

            d = 0.0;
        } else {

            d = ldexp ((double)ie.f1, -20 + (1 - 1023));
            d += ldexp ((double)ie.f2, -(20 + 32) + (1 - 1023));
            if (ie.s)
                d = -d;
        }
    } else if (ie.e == ((1L << 11) - 1 - 1023) + 1023) {
        if (ie.f1 == 0 && ie.f2 == 0) {

            d = OSMath::infinity (ie.s);
        } else {

            d = OSMath::nan ();
        }
    } else {

        d = ldexp (ldexp ((double)ie.f1, -20) +
                   ldexp ((double)ie.f2, -(20 + 32)) +
                   1.0,
                   ie.e - 1023);
        if (ie.s)
            d = -d;
    }
}

void
mico_double2ieee (CORBA::Octet ieee[8], CORBA::Double d)
{
    IeeeDouble &ie = (IeeeDouble &)*ieee;

    if (OSMath::is_nan (d)) {

        ie.s = 0;
        ie.e = ((1L << 11) - 1 - 1023) + 1023;
        ie.f1 = 1;
        ie.f2 = 1;
    } else if (OSMath::is_infinity (d)) {

        ie.s = (d < 0);
        ie.e = ((1L << 11) - 1 - 1023) + 1023;
        ie.f1 = 0;
        ie.f2 = 0;
    } else if (d == 0.0) {

        ie.s = 0;
        ie.e = 0;
        ie.f1 = 0;
        ie.f2 = 0;
    } else {

        int exp;
        double frac = frexp (fabs (d), &exp);

        while (frac < 1.0 && exp >= (1 - 1023)) {
            frac = ldexp (frac, 1);
            --exp;
        }
        if (exp < (1 - 1023)) {

            frac = ldexp (frac, exp - (1 - 1023));
            exp = 0;
        } else {

            ((void) ((1.0 <= frac && frac < 2.0) ? 0 : (__assert_fail ("1.0 <= frac && frac < 2.0", "util.cc", 985, __PRETTY_FUNCTION__), 0)));
            ((void) (((1 - 1023) <= exp && exp <= ((1L << 11) - 1 - 1023)) ? 0 : (__assert_fail ("(1 - 1023) <= exp && exp <= ((1L << 11) - 1 - 1023)", "util.cc", 986, __PRETTY_FUNCTION__), 0)));

            exp += 1023;
            frac -= 1.0;
        }
        ie.s = (d < 0);
        ie.e = exp;
        ie.f1 = (unsigned long)ldexp (frac, 20);
        ie.f2 = (unsigned long)ldexp (frac, (20 + 32));
    }
}

void
mico_ieee2float (CORBA::Octet ieee[4], CORBA::Float &f)
{
    IeeeFloat &ie = (IeeeFloat &)*ieee;

    if (ie.e == 0) {
        if (ie.f == 0) {

            f = 0.0;
        } else {

            f = ldexp ((double)ie.f, -23 + (1 - 127));
            if (ie.s)
                f = -f;
        }
    } else if (ie.e == ((1L << 8) - 1 - 127) + 127) {
        if (ie.f == 0) {

            f = OSMath::infinity (ie.s);
        } else {

            f = OSMath::nan ();
        }
    } else {

        f = ldexp (ldexp ((double)ie.f, -23) + 1.0,
                   ie.e - 127);
        if (ie.s)
            f = -f;
    }
}

void
mico_float2ieee (CORBA::Octet ieee[4], CORBA::Float f)
{
    IeeeFloat &ie = (IeeeFloat &)*ieee;

    if (OSMath::is_nan (f)) {

        ie.s = 0;
        ie.e = ((1L << 8) - 1 - 127) + 127;
        ie.f = 1;
    } else if (OSMath::is_infinity (f)) {

        ie.s = (f < 0);
        ie.e = ((1L << 8) - 1 - 127) + 127;
        ie.f = 0;
    } else if (f == 0.0) {

        ie.s = 0;
        ie.e = 0;
        ie.f = 0;
    } else {

        int exp;
        double frac = frexp (fabs (f), &exp);

        while (frac < 1.0 && exp >= (1 - 127)) {
            frac = ldexp (frac, 1);
            --exp;
        }
        if (exp < (1 - 127)) {

            frac = ldexp (frac, exp - (1 - 127));
            exp = 0;
        } else {

            ((void) ((1.0 <= frac && frac < 2.0) ? 0 : (__assert_fail ("1.0 <= frac && frac < 2.0", "util.cc", 1065, __PRETTY_FUNCTION__), 0)));
            ((void) (((1 - 127) <= exp && exp <= ((1L << 8) - 1 - 127)) ? 0 : (__assert_fail ("(1 - 127) <= exp && exp <= ((1L << 8) - 1 - 127)", "util.cc", 1066, __PRETTY_FUNCTION__), 0)));

            exp += 127;
            frac -= 1.0;
        }
        ie.s = (f < 0);
        ie.e = exp;
        ie.f = (unsigned long)ldexp (frac, 23);
    }
}
# 23 "orb_all.cc" 2
# 1 "fixed.cc" 1
# 23 "fixed.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 24 "fixed.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 25 "fixed.cc" 2
# 1 "/opt/gcc3/include/g++-v3/iostream.h" 1 3
# 26 "fixed.cc" 2
# 1 "/usr/include/ctype.h" 1 3 4
# 27 "fixed.cc" 2
# 1 "../include/mico/os-math.h" 1
# 28 "fixed.cc" 2
# 36 "fixed.cc"
static MICO_LongDouble
power10 (int x)
{
    if (x == 0)
        return 1;
    int neg = 0;
    if (x < 0) {
        neg = 1;
        x = -x;
    }
    MICO_LongDouble s = 1, t = 10;
    while (x) {
        if (x & 1)
            s *= t;
        x >>= 1;
        t *= t;
    }
    if (neg)
        s = 1/s;
    return s;
}

static MICO_LongDouble
epsilonl (MICO_LongDouble v)
{
    static MICO_LongDouble d = 0.0;
    if (d == 0.0) {



        d = 6;
        d /= 10;





        d -= 0.5;
        d *= 10;
        d -= 1;

        int exp;
        frexpl (d, &exp);

        d = ldexpl (1, exp);




    }

    int exp;
    frexpl (v, &exp);
    return ldexpl (d, exp);
}

static MICO_Double
epsilon (MICO_Double v)
{
    static MICO_Double d = 0.0;
    if (d == 0.0) {



        d = 6;
        d /= 10;





        d -= 0.5;
        d *= 10;
        d -= 1;

        int exp;
        frexpl (d, &exp);

        d = ldexpl (1, exp);




    }

    int exp;
    frexp (v, &exp);
    return ldexp (d, exp);
}

static MICO_UShort
digitsl ()
{
    static MICO_UShort digits = 1;

    if (digits == 1) {
        MICO_LongDouble v = 1;

        while (42) {
            v = v*10 + 1;
            if (fmodl (v, 10) != 1)
                break;
            ++digits;
        }
    }
    return digits - 2;
}

static MICO_UShort
digits ()
{
    static MICO_UShort digits = 1;

    if (digits == 1) {
        MICO_Double v = 1;

        while (42) {
            v = v*10 + 1;
            if (fmodl (v, 10) != 1)
                break;
            ++digits;
        }
    }
    return digits - 2;
}

FixedBase::FixedBase ()
    : _digits(0), _scale(0), _val(0.0)
{
}

FixedBase::FixedBase (MICO_Long v)
{
    char buf[100];
    sprintf (buf, "%i", v);
    compute_params (buf, _digits, _scale);
    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (MICO_ULong v)
{
    char buf[100];
    sprintf (buf, "%u", v);
    compute_params (buf, _digits, _scale);
    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (MICO_LongLong v)
{
    char buf[100];

    sprintf (buf, "%i", (MICO_Long)v);
    compute_params (buf, _digits, _scale);
    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (MICO_ULongLong v)
{
    char buf[100];

    sprintf (buf, "%u", (MICO_ULong)v);
    compute_params (buf, _digits, _scale);




    _val = v * power10 (_scale);

    adjust ();
}

FixedBase::FixedBase (MICO_Double v)
{
    MICO_Double v2 = (v < 0 ? -v : v) + epsilon (v);

    char buf[100];
    sprintf (buf, "%.31le", v2);
    compute_params (buf, _digits, _scale, digits());
    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (MICO_LongDouble v)
{
    MICO_LongDouble v2 = (v < 0 ? -v : v) + epsilonl (v);

    char buf[100];

    sprintf (buf, "%.31Le", v2);
    compute_params (buf, _digits, _scale, digitsl());




    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (const char *s)
{
    CORBA::LongDouble v;

    sscanf ((char *)s, "%Lf", &v);
# 252 "fixed.cc"
    compute_params (s, _digits, _scale);
    _val = v * power10 (_scale);
    adjust ();
}

FixedBase::FixedBase (MICO_UShort d, MICO_Short s)
    : _digits(d), _scale(s), _val(0.0)
{
    ((void) ((_digits <= 31) ? 0 : (__assert_fail ("_digits <= 31", "fixed.cc", 260, __PRETTY_FUNCTION__), 0)));
}

FixedBase::FixedBase (const FixedBase &f)
    : _digits(f._digits), _scale(f._scale), _val(f._val)
{
}

FixedBase::~FixedBase ()
{
}

FixedBase::operator CORBA::LongLong () const
{
    return (CORBA::LongLong)(_val / power10 (_scale));
}

FixedBase::operator CORBA::LongDouble () const
{
    return _val / power10 (_scale);
}

FixedBase
FixedBase::round (CORBA::UShort nscale) const
{
    FixedBase f (_digits, nscale);
    f._val = transform (nscale);
    f.adjust (1);
    return f;
}

FixedBase
FixedBase::truncate (MICO_UShort nscale) const
{
    FixedBase f (_digits, nscale);
    f._val = transform (nscale);
    f.adjust (0);
    return f;
}

void
FixedBase::adjust (CORBA::Boolean round)
{
    _val = fmodl (_val, power10 (_digits));
    CORBA::LongDouble delta = round ? 0.5 : 0.0;
    if (_val < 0) {
        _val = ceill (_val - delta);
    } else {
        _val = floorl (_val + delta);
    }
}

MICO_LongDouble
FixedBase::transform (MICO_Short nscale) const
{
    if (_scale == nscale)
        return _val;
    return _val * power10 (nscale - _scale);
}

void
FixedBase::compute_params (const char *str,
                           MICO_UShort &digits, MICO_Short &scale,
                           MICO_UShort max_significant_digits)
{
    while (*str && (isspace(*str) || *str=='+' || *str=='-' || *str=='0'))
        ++str;

    int pos = 0;
    int dot_pos = -1;
    int first_significant_pos = -1;
    int last_significant_pos = 0;

    while (*str && (isdigit(*str) || *str=='.')) {
        if (*str == '.') {
            dot_pos = pos;
        } else {
            if (*str != '0') {
                if (first_significant_pos < 0)
                    first_significant_pos = pos;
                if (pos < max_significant_digits)
                    last_significant_pos = pos+1;
            }
            ++pos;
        }
        ++str;
    }

    if (first_significant_pos < 0)
        first_significant_pos = 0;
    if (dot_pos < 0)

        dot_pos = pos;

    if (*str == 'e' || *str == 'E')
        dot_pos += atol (++str);

    digits = last_significant_pos - first_significant_pos;
    scale = last_significant_pos - dot_pos;
}
# 464 "fixed.cc"
FixedBase::FixedValue*
FixedBase::to_digits () const
{
    FixedValue *digs = new FixedValue;
    digs->length (_digits+1);

    MICO_LongDouble d = fabsl (_val) + 0.5;
    MICO_LongDouble q = power10 (_digits-1);

    for (int i = 0; i < _digits; ++i) {
        int r = (int)(d/q);
        d -= r*q;
        q /= 10;
        (*digs)[i] = (MICO_Octet)r;
    }
    (*digs)[_digits] = _val < 0 ? 1 : 0;

    return digs;
}

void
FixedBase::from_digits (const FixedValue &digs)
{
    ((void) ((digs.length() == (CORBA::ULong)_digits+1) ? 0 : (__assert_fail ("digs.length() == (CORBA::ULong)_digits+1", "fixed.cc", 487, __PRETTY_FUNCTION__), 0)));

    _val = 0.0;

    for (int i = 0; i < _digits; ++i) {
        _val *= 10;
        _val += (CORBA::Octet)digs[i];
    }

    if (digs[_digits])
        _val = -_val;


    adjust ();
}

istream &
FixedBase::read (istream &i)
{




    CORBA::Double d;
    i >> d;
    _val = d * power10 (_scale);
    adjust ();
    return i;
}

ostream &
FixedBase::write (ostream &o) const
{
    FixedValue_var digs = to_digits();
    if (digs[(CORBA::ULong)_digits])
        o << "-";
    if (_scale > _digits) {
        o << ".";
        for (int i = _digits; i < _scale; ++i)
            o << "0";
    }
    for (CORBA::ULong i0 = 0; i0 < _digits; ++i0) {
        if (i0 == (CORBA::ULong)(_digits-_scale))
            o << ".";
        o << (int)(CORBA::Octet)digs[i0];
    }
    for (int i1 = _scale; i1 < 0; ++i1)
        o << "0";
    return o;
}

void
FixedBase::add (FixedBase &res, const FixedBase &a1, const FixedBase a2)
{
    MICO_UShort res_scale;

    if (a1._scale == a2._scale) {
        res._val = a1._val + a2._val;
        res_scale = a1._scale;
    } else if (a1._scale > a2._scale) {
        res._val = a1._val + a2.transform (a1._scale);
        res_scale = a1._scale;
    } else {
        res._val = a1.transform (a2._scale) + a2._val;
        res_scale = a2._scale;
    }
    if (res._scale != res_scale)
        res._val *= power10 (res._scale - res_scale);
    res.adjust ();
}

void
FixedBase::sub (FixedBase &res, const FixedBase &a1, const FixedBase a2)
{
    MICO_UShort res_scale;

    if (a1._scale == a2._scale) {
        res._val = a1._val - a2._val;
        res_scale = a1._scale;
    } else if (a1._scale > a2._scale) {
        res._val = a1._val - a2.transform (a1._scale);
        res_scale = a1._scale;
    } else {
        res._val = a1.transform (a2._scale) - a2._val;
        res_scale = a2._scale;
    }
    if (res._scale != res_scale)
        res._val *= power10 (res._scale - res_scale);
    res.adjust ();
}

void
FixedBase::mul (FixedBase &res, const FixedBase &a1, const FixedBase a2)
{
    res._val = (a1._val * a2._val) / power10 (a2._scale);
    if (res._scale != a1._scale)
        res._val *= power10 (res._scale - a1._scale);
    res.adjust ();
}

void
FixedBase::div (FixedBase &res, const FixedBase &a1, const FixedBase a2)
{
    res._val = (a1._val * power10 (a2._scale)) / a2._val;
    if (res._scale != a1._scale)
        res._val *= power10 (res._scale - a1._scale);
    res.adjust ();
}

void
FixedBase::neg (FixedBase &res, const FixedBase &a)
{
    res._val = - a._val;
    if (res._scale != a._scale)
        res._val *= power10 (res._scale - a._scale);
}

int
FixedBase::eq (const FixedBase &a1, const FixedBase &a2)
{
    if (a1._scale == a2._scale)
        return fabsl (a1._val - a2._val) < 0.1;
    if (a1._scale > a2._scale)
        return fabsl (a1._val - a2.transform (a1._scale)) < 0.1;
    return fabsl (a1.transform (a2._scale) - a2._val) < 0.1;
}

int
FixedBase::lt (const FixedBase &a1, const FixedBase &a2)
{
    if (a1._scale == a2._scale)
        return a1._val < a2._val;
    if (a1._scale > a2._scale)
        return a1._val < a2.transform (a1._scale);
    return a1.transform (a2._scale) < a2._val;
}

int
FixedBase::le (const FixedBase &a1, const FixedBase &a2)
{
    if (a1._scale == a2._scale)
        return a1._val <= a2._val;
    if (a1._scale > a2._scale)
        return a1._val <= a2.transform (a1._scale);
    return a1.transform (a2._scale) <= a2._val;
}

FixedBase &
FixedBase::operator= (const FixedBase &f)
{
    _val = f.transform (_scale);
    adjust ();
    return *this;
}

FixedBase &
FixedBase::operator+= (const FixedBase &f)
{
    FixedBase res (_digits, _scale);
    add (res, *this, f);
    *this = res;
    return *this;
}

FixedBase &
FixedBase::operator-= (const FixedBase &f)
{
    FixedBase res (_digits, _scale);
    sub (res, *this, f);
    *this = res;
    return *this;
}

FixedBase &
FixedBase::operator*= (const FixedBase &f)
{
    FixedBase res (_digits, _scale);
    mul (res, *this, f);
    *this = res;
    return *this;
}

FixedBase &
FixedBase::operator/= (const FixedBase &f)
{
    FixedBase res (_digits, _scale);
    div (res, *this, f);
    *this = res;
    return *this;
}

FixedBase &
FixedBase::operator++ ()
{
    FixedBase res (_digits, _scale);
    add (res, *this, FixedBase ((CORBA::LongDouble)1.0));
    *this = res;
    return *this;
}

FixedBase
FixedBase::operator++ (int)
{
    FixedBase res (*this);
    add (*this, res, FixedBase ((CORBA::LongDouble)1.0));
    return res;
}

FixedBase &
FixedBase::operator-- ()
{
    FixedBase res (_digits, _scale);
    sub (res, *this, FixedBase ((CORBA::LongDouble)1.0));
    *this = res;
    return *this;
}

FixedBase
FixedBase::operator-- (int)
{
    FixedBase res (*this);
    sub (*this, res, FixedBase ((CORBA::LongDouble)1.0));
    return res;
}

FixedBase
FixedBase::operator+ () const
{
    return *this;
}

FixedBase
FixedBase::operator- () const
{
    FixedBase res (_digits, _scale);
    neg (res, *this);
    return res;
}

CORBA::Boolean
FixedBase::operator!() const
{
    return _val == 0;
}



FixedBase
operator+ (const FixedBase &v1, const FixedBase &v2)
{
    CORBA::Short scale = ((v1.fixed_scale())>(v2.fixed_scale())?(v1.fixed_scale()):(v2.fixed_scale()));
    CORBA::UShort digits = 1 +scale + ((v1.fixed_digits()-v1.fixed_scale())>(v2.fixed_digits()-v2.fixed_scale())?(v1.fixed_digits()-v1.fixed_scale()):(v2.fixed_digits()-v2.fixed_scale()));

    if (digits > 31) {
        scale = 31 - digits + scale;
        digits = 31;
    }
    FixedBase res (digits, scale);
    FixedBase::add (res, v1, v2);
    return res;
}

FixedBase
operator- (const FixedBase &v1, const FixedBase &v2)
{
    CORBA::Short scale = ((v1.fixed_scale())>(v2.fixed_scale())?(v1.fixed_scale()):(v2.fixed_scale()));
    CORBA::UShort digits = 1 +scale + ((v1.fixed_digits()-v1.fixed_scale())>(v2.fixed_digits()-v2.fixed_scale())?(v1.fixed_digits()-v1.fixed_scale()):(v2.fixed_digits()-v2.fixed_scale()));

    if (digits > 31) {
        scale = 31 - digits + scale;
        digits = 31;
    }
    FixedBase res (digits, scale);
    FixedBase::sub (res, v1, v2);
    return res;
}

FixedBase
operator* (const FixedBase &v1, const FixedBase &v2)
{
    CORBA::Short scale = v1.fixed_scale() + v2.fixed_scale();
    CORBA::UShort digits = v1.fixed_digits() + v2.fixed_digits();
    if (digits > 31) {
        scale = 31 - digits + scale;
        digits = 31;
    }
    FixedBase res (digits, scale);
    FixedBase::mul (res, v1, v2);
    return res;
}

FixedBase
operator/ (const FixedBase &v1, const FixedBase &v2)
{

    FixedBase res (v1.fixed_digits(), v1.fixed_scale());
    FixedBase::div (res, v1, v2);
    return res;
}



CORBA::Boolean
operator> (const FixedBase &v1, const FixedBase &v2)
{
    return !FixedBase::le (v1, v2);
}

CORBA::Boolean
operator< (const FixedBase &v1, const FixedBase &v2)
{
    return FixedBase::lt (v1, v2);
}

CORBA::Boolean
operator>= (const FixedBase &v1, const FixedBase &v2)
{
    return !FixedBase::lt (v1, v2);
}

CORBA::Boolean
operator<= (const FixedBase &v1, const FixedBase &v2)
{
    return FixedBase::le (v1, v2);
}

CORBA::Boolean
operator== (const FixedBase &v1, const FixedBase &v2)
{
    return FixedBase::eq (v1, v2);
}

CORBA::Boolean
operator!= (const FixedBase &v1, const FixedBase &v2)
{
    return !FixedBase::eq (v1, v2);
}
# 24 "orb_all.cc" 2
# 1 "codeset.cc" 1
# 25 "codeset.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "codeset.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 27 "codeset.cc" 2
# 1 "../include/mico/util.h" 1
# 28 "codeset.cc" 2
# 1 "../include/mico/impl.h" 1
# 29 "codeset.cc" 2
# 1 "../include/mico/intercept.h" 1
# 30 "codeset.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 31 "codeset.cc" 2

# 1 "../include/mico/code_set_registry.h" 1




static CORBA::Codeset::Info _osf_cs_reg[] = {
    { 0x00010001, 1, 1, { 0x0011, 0 }, "ISO 8859-1:1987; Latin Alphabet No. 1", "osf00010001" },
    { 0x00010002, 1, 1, { 0x0012, 0 }, "ISO 8859-2:1987; Latin Alphabet No. 2", "osf00010002" },
    { 0x00010003, 1, 1, { 0x0013, 0 }, "ISO 8859-3:1988; Latin Alphabet No. 3", "osf00010003" },
    { 0x00010004, 1, 1, { 0x0014, 0 }, "ISO 8859-4:1988; Latin Alphabet No. 4", "osf00010004" },
    { 0x00010005, 1, 1, { 0x0015, 0 }, "ISO/IEC 8859-5:1988; Latin-Cyrillic Alphabet", "osf00010005" },
    { 0x00010006, 1, 1, { 0x0016, 0 }, "ISO 8859-6:1987; Latin-Arabic Alphabet", "osf00010006" },
    { 0x00010007, 1, 1, { 0x0017, 0 }, "ISO 8859-7:1987; Latin-Greek Alphabet", "osf00010007" },
    { 0x00010008, 1, 1, { 0x0018, 0 }, "ISO 8859-8:1988; Latin-Hebrew Alphabet", "osf00010008" },
    { 0x00010009, 1, 1, { 0x0019, 0 }, "ISO/IEC 8859-9:1989; Latin Alphabet No. 5", "osf00010009" },
    { 0x0001000a, 1, 1, { 0x001a, 0 }, "ISO/IEC 8859-10:1992; Latin Alphabet No. 6", "osf0001000a" },
    { 0x00010020, 1, 1, { 0x0001, 0 }, "ISO 646:1991 IRV (International Reference Version)", "osf00010020" },
    { 0x00010100, 2, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-2, Level 1", "osf00010100" },
    { 0x00010101, 2, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-2, Level 2", "osf00010101" },
    { 0x00010102, 2, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-2, Level 3", "osf00010102" },
    { 0x00010104, 4, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-4, Level 1", "osf00010104" },
    { 0x00010105, 4, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-4, Level 2", "osf00010105" },
    { 0x00010106, 4, 1, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UCS-4, Level 3", "osf00010106" },
    { 0x00010108, 1, 5, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UTF-1, UCS Transformation Format 1", "osf00010108" },
    { 0x00010109, 2, 2, { 0x1000, 0 }, "ISO/IEC 10646-1:1993; UTF-16, UCS Transformation Format 16-bit form", "osf00010109" },
    { 0x00030001, 1, 1, { 0x0080, 0 }, "JIS X0201:1976; Japanese phonetic characters", "osf00030001" },
    { 0x00030004, 1, 2, { 0x0081, 0 }, "JIS X0208:1978 Japanese Kanji Graphic Characters", "osf00030004" },
    { 0x00030005, 1, 2, { 0x0081, 0 }, "JIS X0208:1983 Japanese Kanji Graphic Characters", "osf00030005" },
    { 0x00030006, 1, 2, { 0x0081, 0 }, "JIS X0208:1990 Japanese Kanji Graphic Characters", "osf00030006" },
    { 0x0003000a, 1, 2, { 0x0082, 0 }, "JIS X0212:1990; Supplementary Japanese Kanji Graphic Chars", "osf0003000a" },
    { 0x00030010, 1, 3, { 0x0011, 0x0080, 0x0081, 0x0082, 0 }, "JIS eucJP:1993; Japanese EUC", "osf00030010" },
    { 0x00040001, 1, 2, { 0x0100, 0 }, "KS C5601:1987; Korean Hangul and Hanja Graphic Characters", "osf00040001" },
    { 0x00040002, 1, 2, { 0x0101, 0 }, "KS C5657:1991; Supplementary Korean Graphic Characters", "osf00040002" },
    { 0x0004000a, 1, 2, { 0x0011, 0x0100, 0x0101, 0 }, "KS eucKR:1991; Korean EUC", "osf0004000a" },
    { 0x00050001, 1, 2, { 0x0180, 0 }, "CNS 11643:1986; Taiwanese Hanzi Graphic Characters", "osf00050001" },
    { 0x00050002, 1, 4, { 0x0181, 0 }, "CNS 11643:1992; Taiwanese Extended Hanzi Graphic Chars", "osf00050002" },
    { 0x0005000a, 1, 4, { 0x0001, 0x0180, 0 }, "CNS eucTW:1991; Taiwanese EUC", "osf0005000a" },
    { 0x00050010, 1, 4, { 0x0001, 0x0181, 0 }, "CNS eucTW:1993; Taiwanese EUC", "osf00050010" },
    { 0x000b0001, 1, 1, { 0x0200, 0 }, "TIS 620-2529, Thai characters", "osf000b0001" },
    { 0x000d0001, 1, 2, { 0x0180, 0 }, "TTB CCDC:1984; Chinese Code for Data Communications", "osf000d0001" },
    { 0x05000010, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "OSF Japanese UJIS", "osf05000010" },
    { 0x05000011, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "OSF Japanese SJIS-1", "osf05000011" },
    { 0x05000012, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "OSF Japanese SJIS-2", "osf05000012" },
    { 0x05010001, 1, 6, { 0x1000, 0 }, "X/Open UTF-8; UCS Transformation Format 8 (UTF-8)", "osf05010001" },
    { 0x05020001, 1, 3, { 0x0001, 0x0080, 0x0081, 0x0082, 0 }, "JVC_eucJP", "osf05020001" },
    { 0x05020002, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "JVC_SJIS", "osf05020002" },
    { 0x10000001, 1, 2, { 0x0011, 0x0080, 0x0081, 0 }, "DEC Kanji", "osf10000001" },
    { 0x10000002, 1, 3, { 0x0011, 0x0080, 0x0081, 0x0082, 0 }, "Super DEC Kanji", "osf10000002" },
    { 0x10000003, 1, 2, { 0x0011, 0x0080, 0x0081, 0 }, "DEC Shift JIS", "osf10000003" },
    { 0x10010001, 1, 1, { 0x0011, 0 }, "HP roman8; English and Western European languages", "osf10010001" },
    { 0x10010002, 1, 1, { 0x0080, 0 }, "HP kana8; Japanese katakana (incl JIS X0201:1976)", "osf10010002" },
    { 0x10010003, 1, 1, { 0x0016, 0 }, "HP arabic8; Arabic", "osf10010003" },
    { 0x10010004, 1, 1, { 0x0017, 0 }, "HP greek8; Greek", "osf10010004" },
    { 0x10010005, 1, 1, { 0x0018, 0 }, "HP hebrew8; Hebrew", "osf10010005" },
    { 0x10010006, 1, 1, { 0x0013, 0x0019, 0 }, "HP turkish8; Turkish", "osf10010006" },
    { 0x10010007, 1, 2, { 0x0001, 0x0300, 0 }, "HP15CN; encoding method for Simplified Chinese", "osf10010007" },
    { 0x10010008, 1, 2, { 0x0001, 0x0180, 0 }, "HP big5; encoding method for Traditional Chinese", "osf10010008" },
    { 0x10010009, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HP japanese15 (sjis); Shift-JIS for mainframe (incl JIS X0208:1990)", "osf10010009" },
    { 0x1001000a, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HP sjishi; Shift-JIS for HP user (incl JIS X0208:1990)", "osf1001000a" },
    { 0x1001000b, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HP sjispc; Shift-JIS for PC (incl JIS X0208:1990)", "osf1001000b" },
    { 0x1001000c, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HP ujis; EUC (incl JIS X0208:1990)", "osf1001000c" },
    { 0x10020025, 1, 1, { 0x0011, 0 }, "IBM-037 (CCSID 00037); CECP for USA, Canada, NL, Ptgl, Brazil, Australia, NZ", "osf10020025" },
    { 0x10020111, 1, 1, { 0x0011, 0 }, "IBM-273 (CCSID 00273); CECP for Austria, Germany", "osf10020111" },
    { 0x10020115, 1, 1, { 0x0011, 0 }, "IBM-277 (CCSID 00277); CECP for Denmark, Norway", "osf10020115" },
    { 0x10020116, 1, 1, { 0x0011, 0 }, "IBM-278 (CCSID 00278); CECP for Finland, Sweden", "osf10020116" },
    { 0x10020118, 1, 1, { 0x0011, 0 }, "IBM-280 (CCSID 00280); CECP for Italy", "osf10020118" },
    { 0x1002011a, 1, 1, { 0x0011, 0 }, "IBM-282 (CCSID 00282); CECP for Portugal", "osf1002011a" },
    { 0x1002011c, 1, 1, { 0x0011, 0 }, "IBM-284 (CCSID 00284); CECP for Spain, Latin America (Spanish)", "osf1002011c" },
    { 0x1002011d, 1, 1, { 0x0011, 0 }, "IBM-285 (CCSID 00285); CECP for United Kingdom", "osf1002011d" },
    { 0x10020122, 1, 1, { 0x0080, 0 }, "IBM-290 (CCSID 00290); Japanese Katakana Host Ext SBCS", "osf10020122" },
    { 0x10020129, 1, 1, { 0x0011, 0 }, "IBM-297 (CCSID 00297); CECP for France", "osf10020129" },
    { 0x1002012c, 1, 2, { 0x0081, 0 }, "IBM-300 (CCSID 00300); Japanese Host DBCS incl 4370 UDC", "osf1002012c" },
    { 0x1002012d, 1, 2, { 0x0081, 0 }, "IBM-301 (CCSID 00301); Japanese PC Data DBCS incl 1880 UDC", "osf1002012d" },
    { 0x100201a4, 1, 1, { 0x0016, 0 }, "IBM-420 (CCSID 00420); Arabic (presentation shapes)", "osf100201a4" },
    { 0x100201a8, 1, 1, { 0x0018, 0 }, "IBM-424 (CCSID 00424); Hebrew", "osf100201a8" },
    { 0x100201b5, 1, 1, { 0x0011, 0 }, "IBM-437 (CCSID 00437); PC USA", "osf100201b5" },
    { 0x100201f4, 1, 1, { 0x0011, 0 }, "IBM-500 (CCSID 00500); CECP for Belgium, Switzerland", "osf100201f4" },
    { 0x10020341, 1, 1, { 0x0001, 0 }, "IBM-833 (CCSID 00833); Korean Host Extended SBCS", "osf10020341" },
    { 0x10020342, 1, 2, { 0x0100, 0 }, "IBM-834 (CCSID 00834); Korean Host DBCS incl 1227 UDC", "osf10020342" },
    { 0x10020343, 1, 2, { 0x0180, 0 }, "IBM-835 (CCSID 00835); T-Ch Host DBCS incl 6204 UDC", "osf10020343" },
    { 0x10020344, 1, 1, { 0x0001, 0 }, "IBM-836 (CCSID 00836); S-Ch Host Extended SBCS", "osf10020344" },
    { 0x10020345, 1, 2, { 0x0300, 0 }, "IBM-837 (CCSID 00837); S-Ch Host DBCS incl 1880 UDC", "osf10020345" },
    { 0x10020346, 1, 1, { 0x0200, 0 }, "IBM-838 (CCSID 00838); Thai Host Extended SBCS", "osf10020346" },
    { 0x10020347, 1, 2, { 0x0200, 0 }, "IBM-839 (CCSID 00839); Thai Host DBCS incl 374 UDC", "osf10020347" },
    { 0x10020352, 1, 1, { 0x0011, 0 }, "IBM-850 (CCSID 00850); Multilingual IBM PC Data-MLP 222", "osf10020352" },
    { 0x10020354, 1, 1, { 0x0012, 0 }, "IBM-852 (CCSID 00852); Multilingual Latin-2", "osf10020354" },
    { 0x10020357, 1, 1, { 0x0015, 0 }, "IBM-855 (CCSID 00855); Cyrillic PC Data", "osf10020357" },
    { 0x10020358, 1, 1, { 0x0018, 0 }, "IBM-856 (CCSID 00856); Hebrew PC Data (extensions)", "osf10020358" },
    { 0x10020359, 1, 1, { 0x0019, 0 }, "IBM-857 (CCSID 00857); Turkish Latin-5 PC Data", "osf10020359" },
    { 0x1002035d, 1, 1, { 0x0011, 0 }, "IBM-861 (CCSID 00861); PC Data Iceland", "osf1002035d" },
    { 0x1002035e, 1, 1, { 0x0018, 0 }, "IBM-862 (CCSID 00862); PC Data Hebrew", "osf1002035e" },
    { 0x1002035f, 1, 1, { 0x0011, 0 }, "IBM-863 (CCSID 00863); PC Data Canadian French", "osf1002035f" },
    { 0x10020360, 1, 1, { 0x0016, 0 }, "IBM-864 (CCSID 00864); Arabic PC Data", "osf10020360" },
    { 0x10020362, 1, 1, { 0x0015, 0 }, "IBM-866 (CCSID 00866); PC Data Cyrillic 2", "osf10020362" },
    { 0x10020364, 1, 1, { 0x0016, 0 }, "IBM-868 (CCSID 00868); Urdu PC Data", "osf10020364" },
    { 0x10020365, 1, 1, { 0x0017, 0 }, "IBM-869 (CCSID 00869); Greek PC Data", "osf10020365" },
    { 0x10020366, 1, 1, { 0x0012, 0 }, "IBM-870 (CCSID 00870); Multilingual Latin-2 EBCDIC", "osf10020366" },
    { 0x10020367, 1, 1, { 0x0011, 0 }, "IBM-871 (CCSID 00871); CECP for Iceland", "osf10020367" },
    { 0x1002036a, 1, 1, { 0x0200, 0 }, "IBM-874 (CCSID 00874); Thai PC Display Extended SBCS", "osf1002036a" },
    { 0x1002036b, 1, 1, { 0x0017, 0 }, "IBM-875 (CCSID 00875); Greek", "osf1002036b" },
    { 0x10020370, 1, 1, { 0x0015, 0 }, "IBM-880 (CCSID 00880); Multilingual Cyrillic", "osf10020370" },
    { 0x1002037b, 1, 1, { 0x0001, 0 }, "IBM-891 (CCSID 00891); Korean PC Data SBCS", "osf1002037b" },
    { 0x10020380, 1, 1, { 0x0080, 0 }, "IBM-896 (CCSID 00896); Japanese Katakana characters; superset of JIS X0201:1976", "osf10020380" },
    { 0x10020381, 1, 1, { 0x0080, 0 }, "IBM-897 (CCSID 00897); PC Data Japanese SBCS (use with CP 00301)", "osf10020381" },
    { 0x10020387, 1, 1, { 0x0001, 0 }, "IBM-903 (CCSID 00903); PC Data Simplified Chinese SBCS (use with DBCS)", "osf10020387" },
    { 0x10020388, 1, 1, { 0x0001, 0 }, "IBM-904 (CCSID 00904); PC Data Traditional Chinese SBCS (use with DBCS)", "osf10020388" },
    { 0x10020396, 1, 1, { 0x0016, 0 }, "IBM-918 (CCSID 00918); Urdu", "osf10020396" },
    { 0x10020399, 1, 1, { 0x001a, 0 }, "IBM-921 (CCSID 00921); Baltic 8-Bit", "osf10020399" },
    { 0x1002039a, 1, 1, { 0x001a, 0 }, "IBM-922 (CCSID 00922); Estonia 8-Bit", "osf1002039a" },
    { 0x1002039e, 1, 2, { 0x0100, 0 }, "IBM-926 (CCSID 00926); Korean PC Data DBCS incl 1880 UDC", "osf1002039e" },
    { 0x1002039f, 1, 2, { 0x0180, 0 }, "IBM-927 (CCSID 00927); T-Ch PC Data DBCS incl 6204 UDC", "osf1002039f" },
    { 0x100203a0, 1, 2, { 0x0300, 0 }, "IBM-928 (CCSID 00928); S-Ch PC Data DBCS incl 1880 UDC", "osf100203a0" },
    { 0x100203a1, 1, 2, { 0x0200, 0 }, "IBM-929 (CCSID 00929); Thai PC Data DBCS incl 374 UDC", "osf100203a1" },
    { 0x100203a2, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-930 (CCSID 00930); Kat-Kanji Host MBCS Ext-SBCS", "osf100203a2" },
    { 0x100203a4, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-932 (CCSID 00932); Japanese PC Data Mixed", "osf100203a4" },
    { 0x100203a5, 1, 2, { 0x0001, 0x0100, 0 }, "IBM-933 (CCSID 00933); Korean Host Extended SBCS", "osf100203a5" },
    { 0x100203a6, 1, 2, { 0x0001, 0x0100, 0 }, "IBM-934 (CCSID 00934); Korean PC Data Mixed", "osf100203a6" },
    { 0x100203a7, 1, 2, { 0x0001, 0x0300, 0 }, "IBM-935 (CCSID 00935); S-Ch Host Mixed", "osf100203a7" },
    { 0x100203a8, 1, 2, { 0x0001, 0x0300, 0 }, "IBM-936 (CCSID 00936); PC Data S-Ch MBCS", "osf100203a8" },
    { 0x100203a9, 1, 2, { 0x0001, 0x0180, 0 }, "IBM-937 (CCSID 00937); T-Ch Host Mixed", "osf100203a9" },
    { 0x100203aa, 1, 2, { 0x0001, 0x0180, 0 }, "IBM-938 (CCSID 00938); PC Data T-Ch MBCS", "osf100203aa" },
    { 0x100203ab, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-939 (CCSID 00939); Latin-Kanji Host MBCS", "osf100203ab" },
    { 0x100203ad, 1, 2, { 0x0081, 0 }, "IBM-941 (CCSID 00941); Japanese PC DBCS for Open", "osf100203ad" },
    { 0x100203ae, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-942 (CCSID 00942); Japanese PC Data Mixed", "osf100203ae" },
    { 0x100203af, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-943 (CCSID 00943); Japanese PC MBCS for Open", "osf100203af" },
    { 0x100203b2, 1, 2, { 0x0001, 0x0300, 0 }, "IBM-946 (CCSID 00946); S-Ch PC Data Mixed", "osf100203b2" },
    { 0x100203b3, 1, 2, { 0x0180, 0 }, "IBM-947 (CCSID 00947); T-Ch PC Data DBCS incl 6204 UDC", "osf100203b3" },
    { 0x100203b4, 1, 2, { 0x0001, 0x0180, 0 }, "IBM-948 (CCSID 00948); T-Ch PC Data Mixed", "osf100203b4" },
    { 0x100203b5, 1, 2, { 0x0001, 0x0100, 0 }, "IBM-949 (CCSID 00949); IBM KS PC Data Mixed", "osf100203b5" },
    { 0x100203b6, 1, 2, { 0x0001, 0x0180, 0 }, "IBM-950 (CCSID 00950); T-Ch PC Data Mixed", "osf100203b6" },
    { 0x100203b7, 1, 2, { 0x0100, 0 }, "IBM-951 (CCSID 00951); IBM KS PC Data DBCS incl 1880 UDC", "osf100203b7" },
    { 0x100203bb, 1, 2, { 0x0081, 0 }, "IBM-955 (CCSID 00955); Japan Kanji characters; superset of JIS X0208:1978", "osf100203bb" },
    { 0x100203c4, 1, 4, { 0x0001, 0x0180, 0 }, "IBM-964 (CCSID 00964); T-Chinese EUC CNS1163 plane 1,2", "osf100203c4" },
    { 0x100203ca, 1, 2, { 0x0011, 0x0100, 0x0101, 0 }, "IBM-970 (CCSID 00970); Korean EUC", "osf100203ca" },
    { 0x100203ee, 1, 1, { 0x0016, 0 }, "IBM-1006 (CCSID 01006); Urdu 8-bit", "osf100203ee" },
    { 0x10020401, 1, 1, { 0x0015, 0 }, "IBM-1025 (CCSID 01025); Cyrillic Multilingual", "osf10020401" },
    { 0x10020402, 1, 1, { 0x0019, 0 }, "IBM-1026 (CCSID 01026); Turkish Latin-5", "osf10020402" },
    { 0x10020403, 1, 1, { 0x0080, 0 }, "IBM-1027 (CCSID 01027); Japanese Latin Host Ext SBCS", "osf10020403" },
    { 0x10020410, 1, 1, { 0x0001, 0 }, "IBM-1040 (CCSID 01040); Korean PC Data Extended SBCS", "osf10020410" },
    { 0x10020411, 1, 1, { 0x0080, 0 }, "IBM-1041 (CCSID 01041); Japanese PC Data Extended SBCS", "osf10020411" },
    { 0x10020413, 1, 1, { 0x0001, 0 }, "IBM-1043 (CCSID 01043); T-Ch PC Data Extended SBCS", "osf10020413" },
    { 0x10020416, 1, 1, { 0x0016, 0 }, "IBM-1046 (CCSID 01046); Arabic PC Data", "osf10020416" },
    { 0x10020417, 1, 1, { 0x0011, 0 }, "IBM-1047 (CCSID 01047); Latin-1 Open System", "osf10020417" },
    { 0x10020440, 1, 1, { 0x0001, 0 }, "IBM-1088 (CCSID 01088); IBM KS Code PC Data SBCS", "osf10020440" },
    { 0x10020449, 1, 1, { 0x0016, 0 }, "IBM-1097 (CCSID 01097); Farsi", "osf10020449" },
    { 0x1002044a, 1, 1, { 0x0016, 0 }, "IBM-1098 (CCSID 01098); Farsi PC Data", "osf1002044a" },
    { 0x10020458, 1, 1, { 0x001a, 0 }, "IBM-1112 (CCSID 01112); Baltic Multilingual", "osf10020458" },
    { 0x1002045a, 1, 1, { 0x0001, 0 }, "IBM-1114 (CCSID 01114); T-Ch PC Data SBCS (IBM BIG-5)", "osf1002045a" },
    { 0x1002045b, 1, 1, { 0x0001, 0 }, "IBM-1115 (CCSID 01115); S-Ch PC Data SBCS (IBM GB)", "osf1002045b" },
    { 0x10020462, 1, 1, { 0x001a, 0 }, "IBM-1122 (CCSID 01122); Estonia", "osf10020462" },
    { 0x100204e2, 1, 1, { 0x0012, 0 }, "IBM-1250 (CCSID 01250); MS Windows Latin-2", "osf100204e2" },
    { 0x100204e3, 1, 1, { 0x0015, 0 }, "IBM-1251 (CCSID 01251); MS Windows Cyrillic", "osf100204e3" },
    { 0x100204e4, 1, 1, { 0x0011, 0 }, "IBM-1252 (CCSID 01252); MS Windows Latin-1", "osf100204e4" },
    { 0x100204e5, 1, 1, { 0x0017, 0 }, "IBM-1253 (CCSID 01253); MS Windows Greek", "osf100204e5" },
    { 0x100204e6, 1, 1, { 0x0019, 0 }, "IBM-1254 (CCSID 01254); MS Windows Turkey", "osf100204e6" },
    { 0x100204e7, 1, 1, { 0x0018, 0 }, "IBM-1255 (CCSID 01255); MS Windows Hebrew", "osf100204e7" },
    { 0x100204e8, 1, 1, { 0x0016, 0 }, "IBM-1256 (CCSID 01256); MS Windows Arabic", "osf100204e8" },
    { 0x100204e9, 1, 1, { 0x001a, 0 }, "IBM-1257 (CCSID 01257); MS Windows Baltic", "osf100204e9" },
    { 0x10020564, 1, 2, { 0x0300, 0 }, "IBM-1380 (CCSID 01380); S-Ch PC Data DBCS incl 1880 UDC", "osf10020564" },
    { 0x10020565, 1, 2, { 0x0001, 0x0300, 0 }, "IBM-1381 (CCSID 01381); S-Ch PC Data Mixed incl 1880 UDC", "osf10020565" },
    { 0x10020567, 1, 3, { 0x0001, 0x0300, 0 }, "IBM-1383 (CCSID 01383); S-Ch EUC GB 2312-80 set (1382)", "osf10020567" },
    { 0x1002112c, 1, 2, { 0x0081, 0 }, "IBM-300 (CCSID 04396); Japanese Host DBCS incl 1880 UDC", "osf1002112c" },
    { 0x10021352, 1, 1, { 0x0011, 0 }, "IBM-850 (CCSID 04946); Multilingual IBM PC Data-190", "osf10021352" },
    { 0x10021354, 1, 1, { 0x0012, 0 }, "IBM-852 (CCSID 04948); Latin-2 Personal Computer", "osf10021354" },
    { 0x10021357, 1, 1, { 0x0015, 0 }, "IBM-855 (CCSID 04951); Cyrillic Personal Computer", "osf10021357" },
    { 0x10021358, 1, 1, { 0x0018, 0 }, "IBM-856 (CCSID 04952); Hebrew PC Data", "osf10021358" },
    { 0x10021359, 1, 1, { 0x0019, 0 }, "IBM-857 (CCSID 04953); Turkish Latin-5 PC Data", "osf10021359" },
    { 0x10021360, 1, 1, { 0x0016, 0 }, "IBM-864 (CCSID 04960); Arabic PC Data (all shapes)", "osf10021360" },
    { 0x10021364, 1, 1, { 0x0016, 0 }, "IBM-868 (CCSID 04964); PC Data for Urdu", "osf10021364" },
    { 0x10021365, 1, 1, { 0x0017, 0 }, "IBM-869 (CCSID 04965); Greek PC Data", "osf10021365" },
    { 0x100213a2, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-5026 (CCSID 05026); Japanese Katakana-Kanji Host Mixed", "osf100213a2" },
    { 0x100213a7, 1, 2, { 0x0001, 0x0300, 0 }, "IBM-5031 (CCSID 05031); S-Ch Host MBCS", "osf100213a7" },
    { 0x100213ab, 1, 2, { 0x0080, 0x0081, 0 }, "IBM-1027 and -300 (CCSID 05035); Japanese Latin-Kanji Host Mixed", "osf100213ab" },
    { 0x100213b8, 1, 2, { 0x0081, 0 }, "IBM-5048 (CCSID 05048); Japanese Kanji characters; superset of JIS X0208:1990 (and 1983)", "osf100213b8" },
    { 0x100213b9, 1, 2, { 0x0082, 0 }, "IBM-5049 (CCSID 05049); Japanese Kanji characters; superset of JIS X0212:1990", "osf100213b9" },
    { 0x100213cb, 1, 2, { 0x0100, 0 }, "IBM-5067 (CCSID 05067); Korean Hangul and Hanja; superset of KS C5601:1987", "osf100213cb" },
    { 0x100221a4, 1, 1, { 0x0016, 0 }, "IBM-420 (CCSID 08612); Arabic (base shapes only)", "osf100221a4" },
    { 0x10022341, 1, 1, { 0x0001, 0 }, "IBM-833 (CCSID 09025); Korean Host SBCS", "osf10022341" },
    { 0x10022342, 1, 2, { 0x0100, 0 }, "IBM-834 (CCSID 09026); Korean Host DBCS incl 1880 UDC", "osf10022342" },
    { 0x10022346, 1, 1, { 0x0200, 0 }, "IBM-838 (CCSID 09030); Thai Host Extended SBCS", "osf10022346" },
    { 0x10022360, 1, 1, { 0x0016, 0 }, "IBM-864 (CCSID 09056); Arabic PC Data (unshaped)", "osf10022360" },
    { 0x1002236a, 1, 1, { 0x0200, 0 }, "IBM-874 (CCSID 09066); Thai PC Display Extended SBCS", "osf1002236a" },
    { 0x100223a5, 1, 2, { 0x0001, 0x0100, 0 }, "IBM-9125 (CCSID 09125); Korean Host Mixed incl 1880 UDC", "osf100223a5" },
    { 0x10026352, 1, 1, { 0x0011, 0 }, "IBM-850 (CCSID 25426); Multilingual IBM PC Display-MLP", "osf10026352" },
    { 0x10026358, 1, 1, { 0x0018, 0 }, "IBM-856 (CCSID 25432); Hebrew PC Display (extensions)", "osf10026358" },
    { 0x10026412, 1, 1, { 0x0001, 0 }, "IBM-1042 (CCSID 25618); S-Ch PC Display Ext SBCS", "osf10026412" },
    { 0x10027025, 1, 1, { 0x0001, 0 }, "IBM-037 (CCSID 28709); T-Ch Host Extended SBCS", "osf10027025" },
    { 0x10028358, 1, 1, { 0x0018, 0 }, "IBM-856 (CCSID 33624); Hebrew PC Display", "osf10028358" },
    { 0x100283ba, 1, 3, { 0x0080, 0x0081, 0x0082, 0 }, "IBM33722 (CCSID 33722); Japanese EUC JISx201,208,212", "osf100283ba" },
    { 0x10030001, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HTCsjis : Hitachi SJIS 90-1", "osf10030001" },
    { 0x10030002, 1, 2, { 0x0001, 0x0080, 0x0081, 0 }, "HTCujis : Hitachi eucJP 90-1", "osf10030002" },
    { 0xffff0001, 1, 1, { 0x0001, 0 }, "ASCII7", "osfffff0001" },
    { 0xffff0002, 1, 1, { 0x0001, 0 }, "EBCDIC", "osfffff0002" },
    { 0xffff0003, 1, 10, { 0x0011, 0 }, "HTML3", "osfffff0003" },
    { 0xffff0004, 1, 1, { 0x0001, 0 }, "MACINTOSH", "osfffff0004" },
    { 0xffff0005, 1, 1, { 0x0001, 0 }, "Windows 3.1 Latin 1", "osfffff0005" },
    { 0xffff0006, 1, 1, { 0x0015, 0 }, "KOI8-R", "osfffff0006" },
    { 0xffff0007, 1, 5, { 0x1000, 0 }, "UTF-7; UCS Transformation Format 7 (UTF-7)", "osfffff0007" },
    { 0x00000000, 0, 0, { 0 }, "", "" }
};
# 33 "codeset.cc" 2



namespace CORBA {
  CORBA::Codeset *Codeset::_special[CORBA::Codeset::_SpecialMax] = { 0 };
  CORBA::Boolean Codeset::_disabled = 0;
};





CORBA::Codeset::Codeset()
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 47, __PRETTY_FUNCTION__), 0)));
}

CORBA::Codeset::Codeset (Info *info)
{
    _info = info;
}

CORBA::Codeset::Codeset (const Codeset &cs)
{
    _info = cs._info;
}

CORBA::Codeset::~Codeset()
{
}

CORBA::Codeset::Info *
CORBA::Codeset::_find_info (CodesetId id)
{
    for (int i = 0; _osf_cs_reg[i].id; ++i) {
        if (id == _osf_cs_reg[i].id)
            return &_osf_cs_reg[i];
    }
    return 0;
}

CORBA::Codeset::Info *
CORBA::Codeset::_find_info (const char *pat)
{
    for (int i = 0; _osf_cs_reg[i].id; ++i) {
        if (mico_fnmatch (_osf_cs_reg[i].desc, pat))
            return &_osf_cs_reg[i];
    }
    return 0;
}

CORBA::Codeset *
CORBA::Codeset::create (CodesetId id)
{
    Info *i = _find_info (id);
    if (!i)
        return 0;
    return new Codeset (i);
}

CORBA::Codeset *
CORBA::Codeset::create (const char *pat)
{
    Info *i = _find_info (pat);
    if (!i)
        return 0;
    return new Codeset (i);
}

CORBA::Codeset *
CORBA::Codeset::special_cs (SpecialCS csid)
{
    ((void) ((_SpecialMin <= csid && csid < _SpecialMax) ? 0 : (__assert_fail ("_SpecialMin <= csid && csid < _SpecialMax", "codeset.cc", 105, __PRETTY_FUNCTION__), 0)));
    return _special[csid];
}

void
CORBA::Codeset::set_special_cs (SpecialCS csid, Codeset *cs)
{
    ((void) ((_SpecialMin <= csid && csid < _SpecialMax) ? 0 : (__assert_fail ("_SpecialMin <= csid && csid < _SpecialMax", "codeset.cc", 112, __PRETTY_FUNCTION__), 0)));
    _special[csid] = cs;
}

CORBA::Boolean
CORBA::Codeset::is_compatible (const Codeset *cs) const
{

    const CharsetId *cp1 = _info->charsets;
    const CharsetId *cp2 = cs->_info->charsets;


    while (*cp1 && *cp2) {
        if (*cp1 < *cp2)
            ++cp1;
        else if (*cp1 > *cp2)
            ++cp2;
        else
            return 1;
    }
    return 0;
}

CORBA::Boolean
CORBA::Codeset::is_compatible (CodesetId id) const
{
    Info *i = _find_info (id);
    if (!i)
        return 0;

    Codeset cs (i);

    return is_compatible (&cs);
}





MICO::CodesetConv::CodesetConv ()
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 153, __PRETTY_FUNCTION__), 0)));
}

MICO::CodesetConv::CodesetConv (CORBA::Codeset *f, CORBA::Codeset *t)
{
    _from = f;
    _to = t;
}

MICO::CodesetConv::CodesetConv (const CodesetConv &csc)
{
    _from = new CORBA::Codeset (*csc._from);
    _to = new CORBA::Codeset (*csc._to);
}

MICO::CodesetConv::~CodesetConv ()
{
    delete _from;
    delete _to;
}

MICO::CodesetConv *
MICO::CodesetConv::create (CORBA::Codeset *f, CORBA::Codeset *t)
{
    if (f->id() == t->id())
        return new CodesetConv (f, t);
    return UniCodesetConv::create (f, t);
}

CORBA::Boolean
MICO::CodesetConv::can_convert (CORBA::Codeset::CodesetId from,
                                CORBA::Codeset::CodesetId to)
{
    if (from == to)
        return 1;
    return UniCodesetConv::can_convert (from, to);
}

MICO::CodesetConv *
MICO::CodesetConv::clone () const
{
    return new CodesetConv (*this);
}

CORBA::Long
MICO::CodesetConv::encode (const CORBA::Char *f, CORBA::ULong len,
                           CORBA::Buffer &t, CORBA::Boolean terminate)
{
    switch (_from->codepoint_size()) {
    case 1: {
        t.put (f, len);
        if (terminate)
            t.put (0);
        break;
    }
    case 2: {
        CORBA::UShort b;
        for (CORBA::Long i = len; --i >= 0; ) {
          b = (CORBA::UShort)*f++;
          t.put (&b, 2);
        }
        if (terminate) {
          b = 0;
          t.put (&b, 2);
        }
        break;
    }
    case 3:
    case 4: {
        CORBA::ULong b;
        for (CORBA::Long i = len; --i >= 0; ) {
          b = (CORBA::ULong) *f++;
          t.put (&b, 4);
        }
        if (terminate) {
          b = 0;
          t.put (&b, 4);
        }
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 234, __PRETTY_FUNCTION__), 0)));
    }

    return len + !!terminate;
}

CORBA::Long
MICO::CodesetConv::encode (const CORBA::WChar *f, CORBA::ULong len,
                           CORBA::Buffer &t, CORBA::Boolean terminate)
{
    switch (_from->codepoint_size()) {
    case 1: {
        for (CORBA::Long i = len; --i >= 0; )
            t.put ((CORBA::Char)*f++);
        if (terminate)
            t.put (0);
        break;
    }
    case 2: {
        CORBA::UShort b;
        for (CORBA::Long i = len; --i >= 0; ) {
          b = (CORBA::UShort)*f++;
          t.put (&b, 2);
        }
        if (terminate) {
          b = 0;
          t.put (&b, 2);
        }
        break;
    }
    case 3:
    case 4: {
        CORBA::ULong b;
        for (CORBA::Long i = len; --i >= 0; ) {
          b = (CORBA::ULong) *f++;
          t.put (&b, 4);
        }
        if (terminate) {
          b = 0;
          t.put (&b, 4);
        }
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 278, __PRETTY_FUNCTION__), 0)));
    }

    return len + !!terminate;
}

CORBA::Long
MICO::CodesetConv::decode (CORBA::Buffer &f, CORBA::ULong len,
                           CORBA::Char *t, CORBA::Boolean terminate)
{
    switch (_from->codepoint_size()) {
    case 1: {
        if (!f.get (t, len))
            return -1;
        if (terminate)
            t[len] = 0;
        break;
    }
    case 2: {
        CORBA::UShort us;
        for (CORBA::Long i = len; --i >= 0; ) {
            if (!f.get (&us, 2))
                return -1;
            *t++ = (CORBA::Char)us;
        }
        if (terminate)
            *t = 0;
        break;
    }
    case 3:
    case 4: {
        CORBA::ULong ul;
        for (CORBA::Long i = len; --i >= 0; ) {
            if (!f.get (&ul, 4))
                return -1;
            *t++ = (CORBA::Char)ul;
        }
        if (terminate)
            *t = 0;
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 320, __PRETTY_FUNCTION__), 0)));
    }

    return len;
}

CORBA::Long
MICO::CodesetConv::decode (CORBA::Buffer &f, CORBA::ULong len,
                           CORBA::WChar *t, CORBA::Boolean terminate)
{
    switch (_from->codepoint_size()) {
    case 1: {
        CORBA::Octet ch;
        for (CORBA::Long i = len; --i >= 0; ) {
            if (!f.get (ch))
                return -1;
            *t++ = (CORBA::WChar)ch;
        }
        if (terminate)
            *t = 0;
        break;
    }
    case 2: {
        CORBA::UShort us;
        for (CORBA::Long i = len; --i >= 0; ) {
            if (!f.get (&us, 2))
                return -1;
            *t++ = (CORBA::WChar)us;
        }
        if (terminate)
            *t = 0;
        break;
    }
    case 3:
    case 4: {
        CORBA::ULong ul;
        for (CORBA::Long i = len; --i >= 0; ) {
            if (!f.get (&ul, 4))
                return -1;
            *t++ = (CORBA::WChar)ul;
        }
        if (terminate)
            *t = 0;
        break;
    }
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 366, __PRETTY_FUNCTION__), 0)));
    }

    return len;
}




# 1 "uni_conversion.h" 1
# 29 "uni_conversion.h"
# 1 "uni_types.h" 1
# 32 "uni_types.h"
# 1 "../include/mico/config.h" 1
# 33 "uni_types.h" 2

# 1 "/opt/gcc3/lib/gcc-lib/i686-pc-linux-gnu/2.97/include/limits.h" 1 3 4
# 35 "uni_types.h" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 36 "uni_types.h" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 37 "uni_types.h" 2

typedef char bits8;
typedef short bits16;
typedef long bits32;



typedef long long bits64;


typedef char uni_byte;
typedef unsigned char uni_ubyte;
typedef unsigned char uni_uchar;
typedef unsigned short uni_ushort;


typedef long uni_slong;
typedef unsigned long uni_ulong;







typedef uni_slong uni_word;
typedef uni_ulong uni_uword;
# 30 "uni_conversion.h" 2

typedef struct
{
  uni_ulong upper;
  uni_ulong lower;
  uni_ushort unicode;
}cconv;

typedef struct
{
  uni_ushort unicode;
  char code;
}cexcept;

typedef struct
{
  const uni_ushort *array;
  uni_ushort offset;
  uni_ubyte size;
}ctounitable;

typedef struct
{
  const char *array;
  uni_ushort offset;
  uni_ubyte size;
  bits32 transMask;
}cfromunitable;

typedef struct
{
  const cexcept *array;
  uni_ubyte size;
}cexcepttable;

extern const ctounitable uni_iso22uniTable;
extern const ctounitable uni_iso32uniTable;
extern const ctounitable uni_iso42uniTable;
extern const ctounitable uni_iso102uniTable;

extern const ctounitable uni_ibm4372uniTable;
extern const ctounitable uni_ibm8502uniTable;
extern const ctounitable uni_ibm8522uniTable;
extern const ctounitable uni_ibm8602uniTable;
extern const ctounitable uni_ibm8632uniTable;
extern const ctounitable uni_ibm8652uniTable;

extern const cconv uni_html2uniArray[];


uni_slong uni_fromUTF8(char *dest, const char *utf8, uni_uword *chars,
                    uni_uword *utf_read,
                    uni_ulong string_type, uni_ubyte line_type,
                    uni_uword *written);
uni_slong uni_toUTF8 (char *utf8, const char *src, uni_uword chars,
                    uni_ulong string_type, uni_ubyte line_type,
                    uni_uword *written);
# 376 "codeset.cc" 2
# 1 "uni_strtypes.h" 1
# 30 "uni_strtypes.h"
enum
{
  C_ASCII7 = 0xffff0001,
  C_EBCDIC = 0xffff0002,
  C_HTML3 = 0xffff0003,
  C_MACINTOSH = 0xffff0004,
  C_KOI8_R = 0xffff0006,

  C_ISO8859_1 = 0x00010001,
  C_ISO8859_2 = 0x00010002,
  C_ISO8859_3 = 0x00010003,
  C_ISO8859_4 = 0x00010004,
  C_ISO8859_5 = 0x00010005,
  C_ISO8859_6 = 0x00010006,
  C_ISO8859_7 = 0x00010007,
  C_ISO8859_8 = 0x00010008,
  C_ISO8859_9 = 0x00010009,
  C_ISO8859_10 = 0x0001000a,

  C_ISO646 = 0x00010020,
  C_UCS2 = 0x00010100,

  C_IBM_437 = 0x100201b5,
  C_IBM_850 = 0x10020352,
  C_IBM_852 = 0x10020354,

  C_IBM_860 = 0x1002011a,
  C_IBM_863 = 0x1002035f,

  C_IBM_865 = 0x10020115,

  C_WIN31_LATIN1 = 0xffff0005,



  C_UCS4 = 0x00010106,
  C_UTF16= 0x00010109,
  C_UTF8 = 0x05010001,
  C_UTF7 = 0xffff0007,


  C_CODEPAGE_AMIGA = C_ISO8859_1,
  C_UNICODE_CALWA = C_UTF8,
  C_CODEPAGE_MAC = C_MACINTOSH,
  C_CODEPAGE_MSDOS = C_IBM_437,
  C_CODEPAGE_UNIX = C_ISO8859_1,
  C_CODEPAFE_WIN31 = C_WIN31_LATIN1,
  C_CODEPAGE_WINNT = C_ISO8859_1,
  C_UNICODE_WINNT = C_UTF16
};

enum
{
  C_LINE_CRLF = 1,
  C_LINE_LF,
  C_LINE_CR,

  C_LINE_AMIGA = C_LINE_LF,
  C_LINE_CALWA = C_LINE_CRLF,
  C_LINE_MAC = C_LINE_CR,
  C_LINE_MSDOS = C_LINE_CRLF,
  C_LINE_UNIX = C_LINE_LF,
  C_LINE_WIN31 = C_LINE_CRLF,
  C_LINE_WINNT = C_LINE_CRLF
};
# 377 "codeset.cc" 2
# 1 "uni_errors.h" 1
# 29 "uni_errors.h"
enum
{

  C_OUT_OF_MEMORY = -100,
  C_NOT_SUPPORTED = -101,
  C_NOT_VALID = -102,
  C_NOT_IMPLEMENTED = -103,
  C_IS_NULL = -103,


  C_NOT_CONNECTED = -200,


  C_NOT_FOUND = -300,
  C_OUT_OF_RANGE = -301,
  C_DUPLICATE_KEY = -302,
  C_INVALID_FORMAT = -303,
  C_UNKNOWN_FORMAT = -304,
  C_EOS = -305,
  C_INVALID_SECONDARY = -306,


  C_CANNOT_READ = -400,
  C_CANNOT_WRITE = -401,
  C_WRITE_DISABLED = -402,


  C_ERROR = -1,
  C_OK = 0,
  C_NO_ERROR = 0
};
# 378 "codeset.cc" 2

MICO::UniCodesetConv::UniCodesetConv ()
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 381, __PRETTY_FUNCTION__), 0)));
}

MICO::UniCodesetConv::UniCodesetConv (CORBA::Codeset *f, CORBA::Codeset *t)
    : MICO::CodesetConv (f, t)
{
}

MICO::UniCodesetConv::UniCodesetConv (const UniCodesetConv &csc)
    : MICO::CodesetConv (csc)
{
}

MICO::UniCodesetConv::~UniCodesetConv ()
{
}

CORBA::Boolean
MICO::UniCodesetConv::supported_csid (CORBA::Codeset::CodesetId csid)
{
    switch (csid) {
    case C_ISO8859_1:
    case C_ISO8859_2:
    case C_ISO8859_3:
    case C_ISO8859_4:
    case C_ISO8859_5:
    case C_ISO8859_6:
    case C_ISO8859_7:
    case C_ISO8859_8:
    case C_ISO8859_9:
    case C_ISO8859_10:
    case C_ISO646:
    case C_UCS2:
    case C_IBM_437:
    case C_IBM_850:
    case C_IBM_852:
    case C_IBM_860:
    case C_IBM_863:
    case C_IBM_865:
    case C_UCS4:
    case C_UTF16:
    case C_UTF8:
    case (uni_ulong)C_WIN31_LATIN1:
    case (uni_ulong)C_ASCII7:
    case (uni_ulong)C_EBCDIC:
    case (uni_ulong)C_MACINTOSH:
    case (uni_ulong)C_KOI8_R:
    case (uni_ulong)C_UTF7:
    case (uni_ulong)C_HTML3:
        return 1;
    default:
        return 0;
    }
}

MICO::CodesetConv *
MICO::UniCodesetConv::create (CORBA::Codeset *f, CORBA::Codeset *t)
{
    if (can_convert (f->id(), t->id()))
        return new UniCodesetConv (f, t);
    return 0;
}

CORBA::Boolean
MICO::UniCodesetConv::can_convert (CORBA::Codeset::CodesetId from,
                                   CORBA::Codeset::CodesetId to)
{
    return supported_csid (from) && supported_csid (to);
}

MICO::CodesetConv *
MICO::UniCodesetConv::clone () const
{
    return new UniCodesetConv (*this);
}

CORBA::Long
MICO::UniCodesetConv::convert (const char *f, CORBA::ULong len, char *t)
{
    if (_from->id() == C_UTF8) {
        CORBA::ULong chars = len, utf_read = 0, written = 0;

        CORBA::Long ret = uni_fromUTF8 (t, f, &chars, &utf_read, _to->id(),
                                        C_LINE_LF, &written);

        if (ret != C_OK) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: codeset conversion error in stage 1" << endl;
          }
          return -1;
        }
        return written;
    }

    if (_to->id() == C_UTF8) {
        CORBA::ULong written = 0;

        CORBA::Long ret = uni_toUTF8 (t, f, len, _from->id(),
                                      C_LINE_LF, &written);

        if (ret != C_OK) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: codeset conversion error in stage 2" << endl;
          }
          return -1;
        }
        return written;
    }



    char tmp[len*6 +1];




    CORBA::ULong chars, utf_read, written;
    CORBA::Long ret = uni_toUTF8 (tmp, f,
                                  len, _from->id(), C_LINE_LF, &chars);

    if (ret != C_OK) {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: codeset conversion error in stage 3" << endl;
      }
      return -1;
    }

    ret = uni_fromUTF8 (t, tmp, &chars, &utf_read, _to->id(),
                        C_LINE_LF, &written);

    if (ret != C_OK) {
      if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
        MICO::Logger::Stream (MICO::Logger::Error)
          << "Error: codeset conversion error in stage 4" << endl;
      }
      return -1;
    }
    return written;
}

CORBA::Long
MICO::UniCodesetConv::encode (const CORBA::Char *f, CORBA::ULong len,
                              CORBA::Buffer &t, CORBA::Boolean terminate)
{
    char *from, *to, *cp;

    CORBA::ULong flen = _from->codepoint_size();
    ((void) ((flen == 1 || flen == 2 || flen == 4) ? 0 : (__assert_fail ("flen == 1 || flen == 2 || flen == 4", "codeset.cc", 531, __PRETTY_FUNCTION__), 0)));
    flen *= len;


    char _f[flen+1];






    switch (_from->codepoint_size()) {
    case 1:
        from = (char *)f;
        break;
    case 2:
        from = cp = (char*) _f;
        {
          for (CORBA::Long i = len; --i >= 0; cp += 2)
            *(CORBA::UShort *)cp = (CORBA::UShort)*f++;
        }
        break;
    case 3:
    case 4:
        from = cp = (char*) _f;
        {
          for (CORBA::Long i = len; --i >= 0; cp += 4)
            *(CORBA::ULong *)cp = (CORBA::ULong)*f++;
        }
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 562, __PRETTY_FUNCTION__), 0)));
    }

    CORBA::ULong tlen = _to->codepoint_size();
    if (tlen == 3)
        tlen = 4;
    tlen *= len * _to->max_codepoints();


    char _t[tlen+4];





    to = (char*) _t;

    CORBA::Long written = convert (from, flen, to);
    if (written < 0)
        return written;
    if (!terminate)
        --written;

    t.put (to, written * _to->codepoint_size());

    return written;
}

CORBA::Long
MICO::UniCodesetConv::encode (const CORBA::WChar *f, CORBA::ULong len,
                              CORBA::Buffer &t, CORBA::Boolean terminate)
{
    char *cp, *from;

    CORBA::ULong flen = _from->codepoint_size();
    ((void) ((flen == 1 || flen == 2 || flen == 4) ? 0 : (__assert_fail ("flen == 1 || flen == 2 || flen == 4", "codeset.cc", 597, __PRETTY_FUNCTION__), 0)));
    ((void) ((sizeof (CORBA::WChar) == 4) ? 0 : (__assert_fail ("sizeof (CORBA::WChar) == 4", "codeset.cc", 598, __PRETTY_FUNCTION__), 0)));
    flen *= len;


    char _f[flen+1];






    switch (_from->codepoint_size()) {
    case 1:
        from = cp = (char*) _f;
        {
          for (CORBA::Long i = len; --i >= 0; ++cp)
            *cp = (CORBA::Char)*f++;
        }
        break;
    case 2:
        from = cp = (char*) _f;
        {
          for (CORBA::Long i = len; --i >= 0; cp += 2)
            *(CORBA::UShort *)cp = (CORBA::UShort)*f++;
        }
        break;
    case 3:
    case 4:
        from = (char *)f;
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 629, __PRETTY_FUNCTION__), 0)));
    }

    CORBA::ULong tlen = _to->codepoint_size();
    if (tlen == 3)
        tlen = 4;
    tlen *= len * _to->max_codepoints();


    char _t[tlen+4];




    CORBA::Long written = convert (from, len, _t);
    if (written < 0)
        return written;
    if (!terminate)
        --written;

    t.put ((char *) _t, written * _to->codepoint_size());

    return written;
}

CORBA::Long
MICO::UniCodesetConv::decode (CORBA::Buffer &f, CORBA::ULong len,
                              CORBA::Char *t, CORBA::Boolean terminate)
{
    char *cp, *from, *to;

    CORBA::ULong flen = _from->codepoint_size();
    if (flen == 3)
        flen = 4;
    flen *= len;


    char _f[flen+1];






    if (!f.get (_f, len * _from->codepoint_size())) {
      return -1;
    }
    _f[len] = 0;

    CORBA::ULong tlen = _to->codepoint_size();
    if (tlen == 3)
        tlen = 4;
    tlen *= len * _to->max_codepoints();


    char _t[tlen+1];






    if (_to->codepoint_size() == 1) {
      to = t;
    }
    else {
      to = (char*) _t;
    }

    CORBA::Long written = convert (_f, flen, to);

    if (written < 0)
        return written;
    if (!terminate)
        --written;

    switch (_to->codepoint_size()) {
    case 1:
        break;
    case 2:
        cp = (char*) _t;
        {
          for (CORBA::Long i = written; --i >= 0; cp += 2)
            *t++ = (CORBA::Char)*(CORBA::UShort *)cp;
        }
        break;
    case 3:
    case 4:
        cp = (char*) _t;
        {
          for (CORBA::Long i = written; --i >= 0; cp += 4)
            *t++ = (CORBA::Char)*(CORBA::ULong *)cp;
        }
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 724, __PRETTY_FUNCTION__), 0)));
    }

    return written;
}

CORBA::Long
MICO::UniCodesetConv::decode (CORBA::Buffer &f, CORBA::ULong len,
                              CORBA::WChar *t, CORBA::Boolean terminate)
{
    char *cp, *to;

    CORBA::ULong flen = _from->codepoint_size();
    if (flen == 3)
        flen = 4;
    flen *= len;


    char _f[flen+1];




    if (!f.get (_f, len * _from->codepoint_size())) {
      return -1;
    }
    _f[len * _from->codepoint_size()] = 0;

    CORBA::ULong tlen = _to->codepoint_size();
    if (tlen == 3)
        tlen = 4;
    tlen *= len * _to->max_codepoints();


    char _t[tlen+1];






    if (_to->codepoint_size() >= 3)
        to = (char *)t;
    else
        to = (char*) _t;

    CORBA::Long written = convert (_f, len, to);

    if (written < 0)
        return written;
    if (!terminate)
        --written;

    switch (_to->codepoint_size()) {
    case 1:
        cp = (char*) _t;
        {
          for (CORBA::Long i = written; --i >= 0; )
            *t++ = *cp++;
        }
        break;
    case 2:
        cp = (char*) _t;
        {
          for (CORBA::Long i = written; --i >= 0; cp += 2)
            *t++ = (CORBA::WChar)*(CORBA::UShort *)cp;
        }
        break;
    case 3:
    case 4:
        break;
    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 796, __PRETTY_FUNCTION__), 0)));
    }

    return written;
}







CORBA::CodeSetCoder::~CodeSetCoder ()
{
}







MICO::GIOP_1_0_CodeSetCoder::GIOP_1_0_CodeSetCoder ()
{
  CORBA::Codeset::CodesetId nativecs =
    ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeCS)->id();

  if (nativecs == 0x00010001uL) {



    _conv = __null;
    _isok = 1;
  }
  else if (!::MICO::CodesetConv::can_convert (nativecs, 0x00010001uL)) {
    _conv = __null;
    _isok = 0;
  }
  else {
    ::CORBA::Codeset * csnative = ::CORBA::Codeset::create (nativecs);
    ::CORBA::Codeset * cstcs = ::CORBA::Codeset::create (0x00010001uL);
    ((void) ((csnative && cstcs) ? 0 : (__assert_fail ("csnative && cstcs", "codeset.cc", 837, __PRETTY_FUNCTION__), 0)));

    _conv = ::MICO::CodesetConv::create (csnative, cstcs);
    _isok = (_conv != __null);
  }
}

MICO::GIOP_1_0_CodeSetCoder::~GIOP_1_0_CodeSetCoder ()
{
  delete _conv;
}

CORBA::CodeSetCoder *
MICO::GIOP_1_0_CodeSetCoder::clone ()
{
  return new GIOP_1_0_CodeSetCoder ();
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::isok ()
{
  return _isok;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_char (CORBA::DataDecoder & decoder,
                                       CORBA::Char & data)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 865, __PRETTY_FUNCTION__), 0)));
  if (!_conv) {
    return decoder.buffer()->get1 (&data);
  }

  if (_conv->decode (*decoder.buffer(), 1, &data, 0) != 1) {
    return 0;
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_chars (CORBA::DataDecoder & decoder,
                                        CORBA::Char * data,
                                        CORBA::ULong count)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 882, __PRETTY_FUNCTION__), 0)));

  if (!_conv) {
    return decoder.buffer()->get (data, count);
  }

  if (_conv->decode (*decoder.buffer(), count, data, 0) != count) {
    return 0;
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_string (CORBA::DataDecoder & decoder,
                                         CORBA::String_out data,
                                         CORBA::ULong bound)
{
  CORBA::ULong length;
  char * buf;

  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 903, __PRETTY_FUNCTION__), 0)));

  if (!decoder.get_ulong (length)) {
    return 0;
  }

  if (length == 0 || (bound > 0 && length-1 > bound)) {
    return 0;
  }

  buf = CORBA::string_alloc (length-1);

  if (!_conv) {
    if (!decoder.buffer()->get (buf, length)) {
      CORBA::string_free (buf);
      return 0;
    }
    if (buf[length-1] != '\0') {
      CORBA::string_free (buf);
      return 0;
    }
  }
  else {
    if (_conv->decode (*decoder.buffer(), length-1, buf, 1) != length) {
      CORBA::string_free (buf);
      return 0;
    }
    if (!decoder.buffer()->get1 (&length)) {
      return 0;
    }
  }

  data = buf;
  return 1;
}





CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_wchar (CORBA::DataDecoder &,
                                        CORBA::WChar &)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_wchars (CORBA::DataDecoder &,
                                         CORBA::WChar *,
                                         CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::get_wstring (CORBA::DataDecoder &,
                                          CORBA::WString_out,
                                          CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_char (CORBA::DataEncoder & encoder,
                                       CORBA::Char data)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 970, __PRETTY_FUNCTION__), 0)));

  if (!_conv) {
    encoder.buffer()->put1 (&data);
    return 1;
  }

  if (_conv->encode (&data, 1, *encoder.buffer(), 0) != 1) {
    return 0;
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_chars (CORBA::DataEncoder & encoder,
                                        const CORBA::Char * data,
                                        CORBA::ULong count)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 989, __PRETTY_FUNCTION__), 0)));

  if (!_conv) {
    encoder.buffer()->put (data, count);
    return 1;
  }

  if (_conv->encode (data, count, *encoder.buffer(), 0) != count) {
    return 0;
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_string (CORBA::DataEncoder & encoder,
                                         const char * data,
                                         CORBA::ULong bound)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1008, __PRETTY_FUNCTION__), 0)));

  CORBA::ULong length = strlen (data);

  if (bound > 0 && length > bound) {
    return 0;
  }

  encoder.put_ulong (length+1);

  if (!_conv) {
    encoder.buffer()->put (data, length+1);
  }
  else {
    if (_conv->encode (data, length, *encoder.buffer(), 0) != length) {
      return 0;
    }
    encoder.put_octet (0);
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_wchar (CORBA::DataEncoder &,
                                        CORBA::WChar)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_wchars (CORBA::DataEncoder &,
                                         const CORBA::WChar *,
                                         CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_0_CodeSetCoder::put_wstring (CORBA::DataEncoder &,
                                          const CORBA::WChar *,
                                          CORBA::ULong)
{
  return 0;
}
# 1066 "codeset.cc"
MICO::GIOP_1_1_CodeSetCoder::GIOP_1_1_CodeSetCoder (CORBA::Codeset::CodesetId tcsc)
{
  CORBA::Codeset::CodesetId nativecs =
    ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeCS)->id();

  _tcsc = tcsc;

  if (tcsc == nativecs && ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeCS)->codepoint_size() == sizeof (CORBA::Char)) {



    _conv_n2t = __null;
    _conv_t2n = __null;
    _isok = 1;
  }
  else if (!::MICO::CodesetConv::can_convert (nativecs, tcsc)) {
    _conv_n2t = __null;
    _conv_t2n = __null;
    _isok = 0;
  }
  else {
    ::CORBA::Codeset * csnative_1 =
      ::CORBA::Codeset::create (nativecs);
    ::CORBA::Codeset * cstcs_1 =
      ::CORBA::Codeset::create (tcsc);

    ::CORBA::Codeset * csnative_2 =
      ::CORBA::Codeset::create (nativecs);
    ::CORBA::Codeset * cstcs_2 =
      ::CORBA::Codeset::create (tcsc);

    ((void) ((csnative_1 && cstcs_1) ? 0 : (__assert_fail ("csnative_1 && cstcs_1", "codeset.cc", 1097, __PRETTY_FUNCTION__), 0)));
    ((void) ((csnative_2 && cstcs_2) ? 0 : (__assert_fail ("csnative_2 && cstcs_2", "codeset.cc", 1098, __PRETTY_FUNCTION__), 0)));

    _codepoint_size = cstcs_1->codepoint_size();
    _max_codepoints = cstcs_1->max_codepoints();

    _conv_n2t = ::MICO::CodesetConv::create (csnative_1, cstcs_1);
    _conv_t2n = ::MICO::CodesetConv::create (cstcs_2, csnative_2);
    _isok = (_conv_n2t != __null && _conv_t2n != __null);
  }
}

MICO::GIOP_1_1_CodeSetCoder::~GIOP_1_1_CodeSetCoder ()
{
  delete _conv_n2t;
  delete _conv_t2n;
}

CORBA::CodeSetCoder *
MICO::GIOP_1_1_CodeSetCoder::clone ()
{
  return new GIOP_1_1_CodeSetCoder (_tcsc);
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::isok ()
{
  return _isok;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_char (CORBA::DataDecoder & decoder,
                                       CORBA::Char & data)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1131, __PRETTY_FUNCTION__), 0)));

  if (!_conv_t2n) {
    decoder.buffer()->get1 (&data);
    return 1;
  }







  if (_max_codepoints == 1 && _codepoint_size == 1) {
    if (_conv_t2n->decode (*decoder.buffer(), 1, &data, 0) != 1) {
      return 0;
    }
  }
  else {
    CORBA::Octet o[8] = {0};
    if (!decoder.buffer()->get1 (o)) {
      return 0;
    }
    CORBA::Buffer buf (o);
    if (_conv_t2n->decode (buf, 1, &data, 0) != 1) {
      return 0;
    }
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_chars (CORBA::DataDecoder & decoder,
                                        CORBA::Char * data,
                                        CORBA::ULong count)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1168, __PRETTY_FUNCTION__), 0)));

  if (!_conv_t2n) {
    decoder.buffer()->get (data, count);
    return 1;
  }

  if (_max_codepoints == 1 && _codepoint_size == 1) {
    if (_conv_t2n->decode (*decoder.buffer(), count, data, 0) != count) {
      return 0;
    }
  }
  else {
    CORBA::Buffer buf (8);

    while (count--) {
      buf.rseek_beg (0);
      *((CORBA::LongLong *) buf.buffer()) = 0;
      if (!decoder.buffer()->get1 (buf.buffer())) {
        return 0;
      }
      if (_conv_t2n->decode (buf, 1, data, 0) != 1) {
        return 0;
      }
      data++;
    }
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_string (CORBA::DataDecoder & decoder,
                                         CORBA::String_out data,
                                         CORBA::ULong bound)
{
  CORBA::ULong length;
  char * buf;

  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1207, __PRETTY_FUNCTION__), 0)));

  if (!decoder.get_ulong (length)) {
    return 0;
  }

  if (length == 0 || (bound > 0 && length-1 > bound)) {
    return 0;
  }

  if (!_conv_t2n) {
    buf = CORBA::string_alloc (length-1);

    if (!decoder.buffer()->get (buf, length)) {
      CORBA::string_free (buf);
      return 0;
    }
    if (buf[length-1] != '\0') {
      CORBA::string_free (buf);
      return 0;
    }
  }
  else if (_max_codepoints == 1 && _codepoint_size == 1) {
    buf = CORBA::string_alloc (length-1);
    if (_conv_t2n->decode (*decoder.buffer(), length-1, buf, 1) != length) {
      CORBA::string_free (buf);
      return 0;
    }
    if (!decoder.buffer()->get1 (&length)) {
      return 0;
    }
  }
  else if (_tcsc == 0x00010109) {




    CORBA::ULong codepoints = length / 2 - 1;
    CORBA::Boolean swap = 0;
    CORBA::Octet bom[2];

    if (codepoints > 0) {
      if (!decoder.buffer()->peek (bom, 2)) {
        return 0;
      }

      if (bom[0] == 0xFE && bom[1] == 0xFF) {






        swap = 1;

        decoder.buffer()->get (bom, 2);
        codepoints--;
      }
      else if (bom[0] == 0xFF && bom[1] == 0xFE) {






        swap = 0;

        decoder.buffer()->get (bom, 2);
        codepoints--;
      }
      else {






        swap = 1;

      }
    }
    else {



      swap = 0;
    }

    buf = CORBA::string_alloc (codepoints);

    if (!swap) {
      if (_conv_t2n->decode (*decoder.buffer(), codepoints, buf, 1) < 0) {
        CORBA::string_free (buf);
        return 0;
      }
    }
    else {




      CORBA::Buffer temp (codepoints*2);
      CORBA::Octet * tptr = temp.buffer ();
      CORBA::ULong count;

      for (count=0; count<codepoints; count++) {
        if (!decoder.buffer()->get (*(tptr+1)) ||
            !decoder.buffer()->get (*tptr)) {
          return 0;
        }
        tptr += 2;
      }

      if (_conv_t2n->decode (temp, codepoints, buf, 1) < 0) {
        CORBA::string_free (buf);
        return 0;
      }
    }

    if (!decoder.buffer()->get (bom, 2)) {
      CORBA::string_free (buf);
      return 0;
    }
  }
  else {
    CORBA::ULong codepoints = length / _codepoint_size - 1;

    buf = CORBA::string_alloc (codepoints);

    if (_conv_t2n->decode (*decoder.buffer(), codepoints, buf, 1) < 0) {
      CORBA::string_free (buf);
      return 0;
    }





    CORBA::ULong cnt = _codepoint_size;

    while (cnt--) {
      if (!decoder.buffer()->get1 (&length)) {
        CORBA::string_free (buf);
        return 0;
      }
    }
  }

  data = buf;
  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_wchar (CORBA::DataDecoder &,
                                        CORBA::WChar &)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_wchars (CORBA::DataDecoder &,
                                         CORBA::WChar *,
                                         CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::get_wstring (CORBA::DataDecoder &,
                                          CORBA::WString_out,
                                          CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_char (CORBA::DataEncoder & encoder,
                                       CORBA::Char data)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1386, __PRETTY_FUNCTION__), 0)));

  if (!_conv_n2t) {
    encoder.buffer()->put1 (&data);
    return 1;
  }

  if (_max_codepoints == 1 && _codepoint_size == 1) {
    if (_conv_n2t->encode (&data, 1, *encoder.buffer(), 0) != 1) {
      return 0;
    }
  }
  else {
    CORBA::Buffer buf (8);
    if (_conv_n2t->encode (&data, 1, buf, 0) <= 0) {
      return 0;
    }
    encoder.buffer()->put1 (buf.buffer());
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_chars (CORBA::DataEncoder & encoder,
                                        const CORBA::Char * data,
                                        CORBA::ULong count)
{
  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1414, __PRETTY_FUNCTION__), 0)));

  if (!_conv_n2t) {
    encoder.buffer()->put (data, count);
    return 1;
  }

  if (_max_codepoints == 1 && _codepoint_size == 1) {
    if (_conv_n2t->encode (data, count, *encoder.buffer(), 0) != count) {
      return 0;
    }
  }
  else {
    CORBA::Buffer buf (8);

    while (count--) {
      buf.wseek_beg (0);
      if (_conv_n2t->encode (data, 1, buf, 0) <= 0) {
        return 0;
      }
      encoder.buffer()->put1 (buf.buffer());
      data++;
    }
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_string (CORBA::DataEncoder & encoder,
                                         const char * data,
                                         CORBA::ULong bound)
{
  CORBA::ULong length = strlen (data);

  ((void) ((_isok) ? 0 : (__assert_fail ("_isok", "codeset.cc", 1449, __PRETTY_FUNCTION__), 0)));

  if (bound > 0 && length > bound) {
    return 0;
  }

  if (!_conv_n2t) {
    encoder.put_ulong (length+1);
    encoder.buffer()->put (data, length+1);
  }
  else if (_max_codepoints == 1 && _codepoint_size == 1) {
    encoder.put_ulong (length+1);
    if (_conv_n2t->encode (data, length, *encoder.buffer(), 0) != length) {
      return 0;
    }
    encoder.put_octet (0);
  }
  else {
    CORBA::ULong npos, pos, cnt;

    encoder.put_ulong ( 0);
    pos = encoder.buffer()->wpos ();







    if (_tcsc == 0x00010109) {
      encoder.buffer()->put2 ("\xFF\xFE");
    }


    if (_conv_n2t->encode (data, length, *encoder.buffer(), 0) < 0) {
      return 0;
    }





    cnt = _codepoint_size;

    while (cnt--) {
      encoder.put_octet (0);
    }





    npos = encoder.buffer()->wpos ();
    encoder.buffer()->wseek_beg (pos-4);
    encoder.put_ulong (npos - pos);
    encoder.buffer()->wseek_beg (npos);
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_wchar (CORBA::DataEncoder &,
                                        CORBA::WChar)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_wchars (CORBA::DataEncoder &,
                                         const CORBA::WChar *,
                                         CORBA::ULong)
{
  return 0;
}

CORBA::Boolean
MICO::GIOP_1_1_CodeSetCoder::put_wstring (CORBA::DataEncoder &,
                                          const CORBA::WChar *,
                                          CORBA::ULong)
{
  return 0;
}







MICO::GIOP_1_2_CodeSetCoder::GIOP_1_2_CodeSetCoder (CORBA::Codeset::CodesetId tcsc,
                                                    CORBA::Codeset::CodesetId tcsw)
  : GIOP_1_1_CodeSetCoder (tcsc)
{
  CORBA::Codeset::CodesetId nativewcs =
    ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeWCS)->id();

  _tcsw = tcsw;

  if (tcsw == nativewcs && ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeWCS)->codepoint_size() == sizeof (CORBA::WChar)) {



    _w_conv_n2t = __null;
    _w_conv_t2n = __null;
    _w_codepoint_size = ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeWCS)->codepoint_size();
    _w_max_codepoints = ::CORBA::Codeset::special_cs(::CORBA::Codeset::NativeWCS)->max_codepoints();
    _w_native_maxcp = _w_max_codepoints;
    _w_isok = 1;
  }
  else if (!::MICO::CodesetConv::can_convert (nativewcs, tcsw)) {
    _w_conv_n2t = __null;
    _w_conv_t2n = __null;
    _w_isok = 0;
  }
  else {
    ::CORBA::Codeset * wcsnative_1 =
      ::CORBA::Codeset::create (nativewcs);
    ::CORBA::Codeset * wcstcs_1 =
      ::CORBA::Codeset::create (tcsw);

    ::CORBA::Codeset * wcsnative_2 =
      ::CORBA::Codeset::create (nativewcs);
    ::CORBA::Codeset * wcstcs_2 =
      ::CORBA::Codeset::create (tcsw);

    ((void) ((wcsnative_1 && wcstcs_1) ? 0 : (__assert_fail ("wcsnative_1 && wcstcs_1", "codeset.cc", 1575, __PRETTY_FUNCTION__), 0)));
    ((void) ((wcsnative_2 && wcstcs_2) ? 0 : (__assert_fail ("wcsnative_2 && wcstcs_2", "codeset.cc", 1576, __PRETTY_FUNCTION__), 0)));

    _w_codepoint_size = wcstcs_1->codepoint_size();
    _w_max_codepoints = wcstcs_1->max_codepoints();
    _w_native_maxcp = wcsnative_1->max_codepoints();
    _w_conv_n2t = ::MICO::CodesetConv::create (wcsnative_1, wcstcs_1);
    _w_conv_t2n = ::MICO::CodesetConv::create (wcstcs_2, wcsnative_2);
    _w_isok = (_w_conv_n2t != __null && _w_conv_t2n != __null);
  }
}

MICO::GIOP_1_2_CodeSetCoder::~GIOP_1_2_CodeSetCoder ()
{
  delete _w_conv_n2t;
  delete _w_conv_t2n;
}

CORBA::CodeSetCoder *
MICO::GIOP_1_2_CodeSetCoder::clone ()
{
  return new GIOP_1_2_CodeSetCoder (_tcsc, _tcsw);
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::isok ()
{
  return _w_isok && GIOP_1_1_CodeSetCoder::isok ();
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::get_wchar (CORBA::DataDecoder & decoder,
                                        CORBA::WChar & data)
{
  CORBA::Octet len;

  ((void) ((_w_isok) ? 0 : (__assert_fail ("_w_isok", "codeset.cc", 1611, __PRETTY_FUNCTION__), 0)));

  if (!decoder.get_octet (len)) {
    return 0;
  }

  if ((len % _w_codepoint_size) != 0) {
    return 0;
  }

  if (!_w_conv_t2n) {



    if (_tcsw == 0x00010109 && len == 4) {
      CORBA::Octet bom[2];
      if (!decoder.buffer()->get (bom, 2)) {
        return 0;
      }
      if (bom[0] == 0xFE && bom[1] == 0xFF) {



        return (decoder.buffer()->get1 (((CORBA::Octet *) &data) + 1) &&
                decoder.buffer()->get1 (((CORBA::Octet *) &data)));

      }
      else if (bom[0] == 0xFF && bom[1] == 0xFE) {




        return decoder.buffer()->get (&data, 2);

      }
      else {

        return 0;
      }
    }
    else if (_tcsw == 0x00010109 && len == 2) {



      return (decoder.buffer()->get1 (((CORBA::Octet *) &data) + 1) &&
              decoder.buffer()->get1 (((CORBA::Octet *) &data)));

    }
    if (len != _w_codepoint_size) {

      return 0;
    }
    return decoder.buffer()->get (&data, _w_codepoint_size);
  }
  else if (_tcsw == 0x00010109) {




    CORBA::Boolean swap = 0;

    if (len == 4) {
      CORBA::Octet bom[2];
      if (!decoder.buffer()->get (bom, 2)) {
        return 0;
      }
      if (bom[0] == 0xFE && bom[1] == 0xFF) {



        swap = 1;

      }
      else if (bom[0] == 0xFF && bom[1] == 0xFE) {



        swap = 0;

      }
      else {

        return 0;
      }
    }
    else if (len == 2) {



      swap = 1;

    }
    else {

      return 0;
    }

    if (swap == 0) {
      if (_w_conv_t2n->decode (*decoder.buffer(), 1, &data, 0) != 1) {
        return 0;
      }
    }
    else {
      CORBA::Buffer temp (2);
      if (!decoder.buffer()->get1 (temp.buffer()+1) ||
          !decoder.buffer()->get1 (temp.buffer())) {
        return 0;
      }
      temp.wseek_beg (2);
      if (_w_conv_t2n->decode (temp, 1, &data, 0) != 1) {
        return 0;
      }
    }
  }
  else if (len == _w_codepoint_size) {
    if (_w_conv_t2n->decode (*decoder.buffer(), 1, &data, 0) != 1) {
      return 0;
    }
  }
  else {

    CORBA::WChar o[len];



    if (_w_conv_t2n->decode (*decoder.buffer(), len / _w_codepoint_size,
                             (wchar_t*)o, 0) <= 0) {
      return 0;
    }
    data = o[(CORBA::ULong)0];
  }

  return 1;
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::get_wchars (CORBA::DataDecoder & decoder,
                                         CORBA::WChar * data,
                                         CORBA::ULong count)
{




  while (count--) {
    if (!get_wchar (decoder, *data++)) {
      return 0;
    }
  }
  return 1;
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::get_wstring (CORBA::DataDecoder & decoder,
                                          CORBA::WString_out data,
                                          CORBA::ULong bound)
{
  CORBA::ULong length;
  CORBA::WChar * buf;

  ((void) ((_w_isok) ? 0 : (__assert_fail ("_w_isok", "codeset.cc", 1771, __PRETTY_FUNCTION__), 0)));

  if (!decoder.get_ulong (length)) {
    return 0;
  }

  if ((length % _w_codepoint_size) != 0) {
    return 0;
  }

  if (!_w_conv_t2n) {




    if (_tcsw == 0x00010109) {
      CORBA::Boolean swap = 0;

      if (length >= 2) {
        CORBA::Octet bom[2];
        if (!decoder.buffer()->peek (bom, 2)) {
          return 0;
        }
        if (bom[0] == 0xFE && bom[1] == 0xFF) {



          swap = 1;

          decoder.buffer()->get (bom, 2);
          length -= 2;
        }
        else if (bom[0] == 0xFF && bom[1] == 0xFE) {



          swap = 0;

          decoder.buffer()->get (bom, 2);
          length -= 2;
        }
        else {



          swap = 1;

        }
      }

      buf = CORBA::wstring_alloc (length / 2);

      if (!swap) {
        if (!decoder.buffer()->get (buf, length)) {
          CORBA::wstring_free (buf);
          return 0;
        }
        buf[length / 2] = 0;
      }
      else {
        CORBA::WChar * ptr = buf;
        while (length) {
          if (!decoder.buffer()->get1 (((CORBA::Octet *) ptr) + 1) ||
              !decoder.buffer()->get1 (((CORBA::Octet *) ptr))) {
            return 0;
          }
          length -= 2;
          ptr++;
        }
      }
    }
    else {




      buf = CORBA::wstring_alloc (length / _w_codepoint_size);
      if (!decoder.buffer()->get (buf, length)) {
        CORBA::wstring_free (buf);
        return 0;
      }
      buf[length / _w_codepoint_size] = 0;
    }
  }
  else if (_tcsw == 0x00010109) {




    CORBA::ULong codepoints = length / 2;
    CORBA::Boolean swap = 0;
    CORBA::Octet bom[2];

    if (codepoints > 0) {
      if (!decoder.buffer()->peek (bom, 2)) {
        return 0;
      }

      if (bom[0] == 0xFE && bom[1] == 0xFF) {






        swap = 1;

        decoder.buffer()->get (bom, 2);
        codepoints--;
      }
      else if (bom[0] == 0xFF && bom[1] == 0xFE) {






        swap = 0;

        decoder.buffer()->get (bom, 2);
        codepoints--;
      }
      else {






        swap = 1;

      }
    }
    else {



      swap = 0;
    }

    buf = CORBA::wstring_alloc (codepoints * _w_native_maxcp);

    if (!swap) {
      if (_w_conv_t2n->decode (*decoder.buffer(), codepoints, buf, 1) < 0) {
        CORBA::wstring_free (buf);
        return 0;
      }
    }
    else {




      CORBA::Buffer temp (codepoints*2);
      CORBA::Octet * tptr = temp.buffer ();
      CORBA::ULong count;

      for (count=0; count<codepoints; count++) {
        if (!decoder.buffer()->get1 (tptr + 1) ||
            !decoder.buffer()->get1 (tptr)) {
          return 0;
        }
        tptr += 2;
      }

      temp.wseek_beg (codepoints*2);

      if (_w_conv_t2n->decode (temp, codepoints, buf, 1) < 0) {
        CORBA::wstring_free (buf);
        return 0;
      }
    }
  }
  else {




    buf = CORBA::wstring_alloc (length / _w_codepoint_size * _w_native_maxcp);
    CORBA::Long len = _w_conv_t2n->decode (*decoder.buffer(),
                                           length / _w_codepoint_size,
                                           buf, 0);
    if (len < 0) {
      return 0;
    }
    buf[len] = 0;
  }

  data = buf;
  return 1;
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::put_wchar (CORBA::DataEncoder & encoder,
                                        CORBA::WChar data)
{
  ((void) ((_w_isok) ? 0 : (__assert_fail ("_w_isok", "codeset.cc", 1967, __PRETTY_FUNCTION__), 0)));

  if (!_w_conv_n2t) {

    if (_tcsw == 0x00010109) {




      encoder.put_octet (4);
      encoder.buffer()->put ("\xFF\xFE", 2);
      encoder.buffer()->put (&data, 2);
      return 1;
    }


    encoder.put_octet (_w_codepoint_size);
    encoder.buffer()->put (&data, _w_codepoint_size);
    return 1;
  }
  else {
    CORBA::ULong pos, npos;
    encoder.put_octet (_w_codepoint_size);
    pos = encoder.buffer()->wpos ();


    if (_tcsw == 0x00010109) {




      encoder.buffer()->put ("\xFF\xFE", 2);
    }


    if (_w_conv_n2t->encode (&data, 1, *encoder.buffer(), 0) <= 0) {
      return 0;
    }
    npos = encoder.buffer()->wpos ();

    if (npos - pos != _w_codepoint_size) {



      encoder.buffer()->wseek_beg (pos - 1);
      encoder.put_octet (npos - pos);
      encoder.buffer()->wseek_beg (npos);
    }
  }
  return 1;
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::put_wchars (CORBA::DataEncoder & decoder,
                                         const CORBA::WChar * data,
                                         CORBA::ULong count)
{




  while (count) {
    if (!put_wchar (decoder, *data++)) {
      return 0;
    }
  }
  return 1;
}

CORBA::Boolean
MICO::GIOP_1_2_CodeSetCoder::put_wstring (CORBA::DataEncoder & encoder,
                                          const CORBA::WChar * data,
                                          CORBA::ULong bound)
{
  CORBA::ULong length = xwcslen (data);

  ((void) ((_w_isok) ? 0 : (__assert_fail ("_w_isok", "codeset.cc", 2043, __PRETTY_FUNCTION__), 0)));

  if (bound > 0 && length > bound) {
    return 0;
  }

  if (!_w_conv_n2t) {

    if (_tcsw == 0x00010109) {
      encoder.put_ulong (length * _w_codepoint_size + 2);
      encoder.buffer()->put2 ("\xFF\xFE");
      encoder.buffer()->put (data, length * _w_codepoint_size);
      return 1;
    }

    encoder.put_ulong (length * _w_codepoint_size);
    encoder.buffer()->put (data, length * _w_codepoint_size);
  }
  else {
    CORBA::ULong pos, npos;

    encoder.put_ulong ( 0);
    pos = encoder.buffer()->wpos ();


    if (_tcsw == 0x00010109) {




      encoder.buffer()->put2 ("\xFF\xFE");
    }


    if (_w_conv_n2t->encode (data, length, *encoder.buffer(), 0) < 0) {
      return 0;
    }





    npos = encoder.buffer()->wpos ();
    encoder.buffer()->wseek_beg (pos-4);
    encoder.put_ulong (npos - pos);
    encoder.buffer()->wseek_beg (npos);
  }

  return 1;
}







MICO::CodesetComponent::CodesetComponent ()
    : _native_cs (0), _native_wcs (0),
      _selected_cs (0), _selected_wcs (0)
{
}

MICO::CodesetComponent::CodesetComponent (CodeSetId native_cs,
                                          CodeSetId native_wcs,
                                          const vector<CodeSetId> &conv_cs,
                                          const vector<CodeSetId> &conv_wcs)
    : _native_cs (native_cs), _native_wcs (native_wcs),
      _conv_cs (conv_cs), _conv_wcs (conv_wcs),
      _selected_cs (0), _selected_wcs (0)
{
}

MICO::CodesetComponent::CodesetComponent (const CodesetComponent &csc)
    : _native_cs (csc._native_cs), _native_wcs (csc._native_wcs),
      _conv_cs (csc._conv_cs), _conv_wcs (csc._conv_wcs),
      _selected_cs (csc._selected_cs), _selected_wcs (csc._selected_wcs)
{
}

MICO::CodesetComponent::~CodesetComponent ()
{
}

void
MICO::CodesetComponent::encode (CORBA::DataEncoder &ec) const
{

    ec.struct_begin();
    {

        ec.struct_begin();
        {

            ec.put_ulong (_native_cs);

            ec.seq_begin (_conv_cs.size());
            for (mico_vec_size_type i = 0; i < _conv_cs.size(); ++i)
                ec.put_ulong (_conv_cs[i]);
            ec.seq_end ();
        }
        ec.struct_end();


        ec.struct_begin();
        {

            ec.put_ulong (_native_wcs);

            ec.seq_begin (_conv_wcs.size());
            for (mico_vec_size_type i = 0; i < _conv_wcs.size(); ++i)
                ec.put_ulong (_conv_wcs[i]);
            ec.seq_end ();
        }
        ec.struct_end();
    }
    ec.struct_end();
}

CORBA::Component::ComponentId
MICO::CodesetComponent::id () const
{
    return TAG_CODE_SETS;
}

void
MICO::CodesetComponent::print (ostream &o) const
{
  CORBA::Codeset::Info * nci = CORBA::Codeset::_find_info (_native_cs);
  CORBA::Codeset::Info * nwi = CORBA::Codeset::_find_info (_native_wcs);

  o << "Native Codesets:" << endl;
  o << "              normal: ";

  if (nci) {
    o << nci->desc << endl;
  }
  else {
    o << "0x" << hex << _native_cs << endl;
  }

  o << "                wide: ";

  if (nwi) {
    o << nwi->desc << endl;
  }
  else {
    o << "0x" << hex << _native_wcs << endl;
  }

  if (_conv_cs.size() > 0) {
    o << "              Other Codesets: " << endl;
    for (mico_vec_size_type i = 0; i < _conv_cs.size(); i++) {
      nci = CORBA::Codeset::_find_info (_conv_cs[i]);
      o << "                      ";
      if (nci) {
        o << nci->desc << endl;
      }
      else {
        o << "0x" << hex << _conv_cs[i] << endl;
      }
    }
  }

  if (_conv_wcs.size() > 0) {
    o << "              Other Wide Codesets: " << endl;
    for (mico_vec_size_type i = 0; i < _conv_wcs.size(); i++) {
      nwi = CORBA::Codeset::_find_info (_conv_wcs[i]);
      o << "                      ";
      if (nwi) {
        o << nwi->desc << endl;
      }
      else {
        o << "0x" << hex << _conv_wcs[i] << endl;
      }
    }
  }
}

CORBA::Component *
MICO::CodesetComponent::clone () const
{
    return new CodesetComponent (*this);
}

CORBA::Long
MICO::CodesetComponent::compare (const CORBA::Component &c) const
{
    if (id() != c.id())
        return (CORBA::Long)id() - (CORBA::Long)c.id();

    CodesetComponent &csc = (CodesetComponent &)c;

    if (_native_cs != csc._native_cs)
        return (CORBA::Long)_native_cs - (CORBA::Long)csc._native_cs;

    if (_native_wcs != csc._native_wcs)
        return (CORBA::Long)_native_wcs - (CORBA::Long)csc._native_wcs;

    CORBA::Long r = mico_vec_compare (_conv_cs, csc._conv_cs);
    if (r)
        return r;

    return mico_vec_compare (_conv_wcs, csc._conv_wcs);
}

CORBA::Boolean
MICO::CodesetComponent::operator== (const CORBA::Component &c) const
{
    return compare (c) == 0;
}

CORBA::Boolean
MICO::CodesetComponent::operator< (const CORBA::Component &c) const
{
    return compare (c) < 0;
}

MICO::CodesetComponent::CodeSetId
MICO::CodesetComponent::selected_cs ()
{
    if (_selected_cs)
        return _selected_cs;

    CodeSetId cl_nat =
        CORBA::Codeset::special_cs (CORBA::Codeset::NativeCS)->id();

    CodeSetId sv_nat = _native_cs;




    if (!_native_cs && !_conv_cs.size())
        sv_nat = CORBA::Codeset::special_cs(CORBA::Codeset::DefaultCS)->id();


    if (sv_nat == cl_nat) {
        _selected_cs = cl_nat;
        return _selected_cs;
    }

    if (MICO::CodesetConv::can_convert (cl_nat, sv_nat)) {
        _selected_cs = sv_nat;
        return _selected_cs;
    }

    for (mico_vec_size_type i = 0; i < _conv_cs.size(); ++i) {
        if (cl_nat == _conv_cs[i]) {
            _selected_cs = cl_nat;
            return _selected_cs;
        }
    }




    {
      for (mico_vec_size_type i = 0; i < _conv_cs.size(); ++i) {
        if (MICO::CodesetConv::can_convert (cl_nat, _conv_cs[i])) {
          _selected_cs = _conv_cs[i];
          return _selected_cs;
        }
      }
    }

    _selected_cs =
        CORBA::Codeset::special_cs(CORBA::Codeset::FallbackCS)->id();
    return _selected_cs;
}

MICO::CodesetComponent::CodeSetId
MICO::CodesetComponent::selected_wcs ()
{
    if (_selected_wcs)
        return _selected_wcs;

    CodeSetId cl_nat =
        CORBA::Codeset::special_cs (CORBA::Codeset::NativeWCS)->id();

    CodeSetId sv_nat = _native_wcs;




    if (!_native_wcs && !_conv_wcs.size())
        sv_nat = CORBA::Codeset::special_cs(CORBA::Codeset::DefaultWCS)->id();


    if (sv_nat == cl_nat) {
        _selected_wcs = cl_nat;
        return _selected_wcs;
    }

    if (MICO::CodesetConv::can_convert (cl_nat, sv_nat)) {
        _selected_wcs = sv_nat;
        return _selected_wcs;
    }

    for (mico_vec_size_type i = 0; i < _conv_wcs.size(); ++i) {
        if (cl_nat == _conv_wcs[i]) {
            _selected_wcs = cl_nat;
            return _selected_wcs;
        }
    }




    {
      for (mico_vec_size_type i = 0; i < _conv_wcs.size(); ++i) {
        if (MICO::CodesetConv::can_convert (cl_nat, _conv_wcs[i])) {
          _selected_wcs = _conv_wcs[i];
          return _selected_wcs;
        }
      }
    }

    _selected_wcs =
        CORBA::Codeset::special_cs(CORBA::Codeset::FallbackWCS)->id();
    return _selected_wcs;
}





MICO::CodesetComponentDecoder::CodesetComponentDecoder ()
{
    CORBA::Component::register_decoder (this);
}

MICO::CodesetComponentDecoder::~CodesetComponentDecoder ()
{
    CORBA::Component::unregister_decoder (this);
}



CORBA::Component *
MICO::CodesetComponentDecoder::decode (CORBA::DataDecoder &dc,
                                       ComponentId, CORBA::ULong) const
{
    CodesetComponent::CodeSetId native_cs, native_wcs;
    vector<CodesetComponent::CodeSetId> conv_cs, conv_wcs;
    CORBA::ULong len;


    if (!(dc.struct_begin())) return 0;;
    {

        if (!(dc.struct_begin())) return 0;;
        {

            if (!(dc.get_ulong (native_cs))) return 0;;

            if (!(dc.seq_begin (len))) return 0;;
            CORBA::ULong cs;
            for (CORBA::ULong i = 0; i < len; ++i) {
                if (!(dc.get_ulong (cs))) return 0;;
                conv_cs.push_back (cs);
            }
            if (!(dc.seq_end ())) return 0;;
        }
        if (!(dc.struct_end())) return 0;;


        if (!(dc.struct_begin())) return 0;;
        {

            if (!(dc.get_ulong (native_wcs))) return 0;;

            if (!(dc.seq_begin (len))) return 0;;
            CORBA::ULong cs;
            for (CORBA::ULong i = 0; i < len; ++i) {
                if (!(dc.get_ulong (cs))) return 0;;
                conv_wcs.push_back (cs);
            }
            if (!(dc.seq_end ())) return 0;;
        }
        if (!(dc.struct_end())) return 0;;
    }
    if (!(dc.struct_end())) return 0;;

    return new CodesetComponent (native_cs, native_wcs, conv_cs, conv_wcs);
}



CORBA::Boolean
MICO::CodesetComponentDecoder::has_id (ComponentId id) const
{
    return id == CORBA::Component::TAG_CODE_SETS;
}

static MICO::CodesetComponentDecoder codeset_component_decoder;





static class CodesetInit : public Interceptor::InitInterceptor {
public:
    CodesetInit ()
        : Interceptor::InitInterceptor (0)
    {
    }
    Interceptor::Status initialize (CORBA::ORB_ptr orb,
                                    const char *orbid,
                                    int &argc, char *argv[])
    {
        MICOGetOpt::OptMap opts;
        opts["-ORBNativeCS"] = "arg-expected";
        opts["-ORBNativeWCS"] = "arg-expected";
        opts["-ORBNoCodeSets"] = "";

        MICOGetOpt opt_parser (opts);
        CORBA::Boolean r = opt_parser.parse (orb->rcfile(), 1);
        ((void) ((r) ? 0 : (__assert_fail ("r", "codeset.cc", 2460, __PRETTY_FUNCTION__), 0)));
        r = opt_parser.parse (argc, argv, 1);
        ((void) ((r) ? 0 : (__assert_fail ("r", "codeset.cc", 2462, __PRETTY_FUNCTION__), 0)));

        const char *cs_name = 0;
        const char *wcs_name = 0;
        CORBA::Boolean disable = 0;

        const MICOGetOpt::OptVec &o = opt_parser.opts();
        MICOGetOpt::OptVec::const_iterator i;
        for (i = o.begin(); i != o.end(); ++i) {
            const string &arg = (*i).first;
            const string &val = (*i).second;
            if (arg == "-ORBNativeCS") {
                cs_name = val.c_str();
            } else if (arg == "-ORBNativeWCS") {
                wcs_name = val.c_str();
            } else if (arg == "-ORBNoCodeSets") {
                disable = 1;
            }
        }

        CORBA::Codeset::disable (disable);


        if (!cs_name)
            cs_name = "*8859-1*";

        CORBA::Codeset *cs = CORBA::Codeset::create (cs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown native char code set: " << cs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2494, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::NativeCS, cs);


        if (!wcs_name)
            wcs_name = "*UTF-16*";

        cs = CORBA::Codeset::create (wcs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown native wide char code set: "
              << wcs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2509, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::NativeWCS, cs);


        cs_name = "*8859-1*";
        cs = CORBA::Codeset::create (cs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown default char code set: " << cs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2521, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::DefaultCS, cs);


        cs_name = "*UTF-16*";
        cs = CORBA::Codeset::create (cs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown default wide char code set: "
              << cs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2534, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::DefaultWCS, cs);


        cs_name = "*UTF-8*";
        cs = CORBA::Codeset::create (cs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown fallback char code set: "
              << cs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2547, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::FallbackCS, cs);


        cs_name = "*UTF-16*";
        cs = CORBA::Codeset::create (cs_name);
        if (!cs) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: unknown fallback wide char code set: "
              << cs_name << endl;
          }
          ((void) ((0) ? 0 : (__assert_fail ("0", "codeset.cc", 2560, __PRETTY_FUNCTION__), 0)));
        }
        CORBA::Codeset::set_special_cs (CORBA::Codeset::FallbackWCS, cs);



        if (!disable) {
            MICO::MultiCompProfile *mcp =
                new MICO::MultiCompProfile (CORBA::MultiComponent());

            mcp->components()->add_component (new MICO::CodesetComponent (
                CORBA::Codeset::special_cs(CORBA::Codeset::NativeCS)->id(),
                CORBA::Codeset::special_cs(CORBA::Codeset::NativeWCS)->id(),
                vector<MICO::CodesetComponent::CodeSetId>(),
                vector<MICO::CodesetComponent::CodeSetId>()));
            orb->ior_template()->add_profile (mcp);
        }

        return Interceptor::INVOKE_CONTINUE;
    }
} __cs_init;

void
CORBA::Codeset::_init ()
{
  __cs_init;
}
# 25 "orb_all.cc" 2
# 1 "queue.cc" 1
# 25 "queue.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "queue.cc" 2
# 1 "../include/mico/util.h" 1
# 27 "queue.cc" 2
# 1 "../include/mico/impl.h" 1
# 28 "queue.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 29 "queue.cc" 2





MICO::ReqQueueRec::ReqQueueRec (MsgId id, CORBA::ORBRequest *req,
                                CORBA::Object_ptr obj,
                                CORBA::Principal_ptr pr,
                                CORBA::Boolean resp)
{
    _id = id;
    _request = CORBA::ORBRequest::_duplicate (req);
    _obj = CORBA::Object::_duplicate (obj);
    _pr = CORBA::Principal::_duplicate (pr);
    _response_exp = resp;
    _type = CORBA::RequestInvoke;
}

MICO::ReqQueueRec::ReqQueueRec (MsgId id, const char *repoid,
                                const CORBA::ORB::ObjectTag &tag)
{
    _id = id;
    _repoid = repoid;
    _request = CORBA::ORBRequest::_nil();
    _obj = CORBA::Object::_nil();
    _pr = CORBA::Principal::_nil();
    _type = CORBA::RequestBind;
    _tag = tag;
}

MICO::ReqQueueRec::ReqQueueRec (MsgId id, CORBA::Object_ptr obj)
{
    _id = id;
    _request = CORBA::ORBRequest::_nil();
    _obj = CORBA::Object::_duplicate (obj);
    _pr = CORBA::Principal::_nil();
    _type = CORBA::RequestLocate;
}

MICO::ReqQueueRec::~ReqQueueRec ()
{
    CORBA::release (_request);
    CORBA::release (_obj);
    CORBA::release (_pr);
}

void
MICO::ReqQueueRec::exec (CORBA::ObjectAdapter *oa, CORBA::ORB_ptr orb)
{
    switch (_type) {
    case CORBA::RequestInvoke:
        oa->invoke (_id, _obj, _request, _pr, _response_exp);
        break;

    case CORBA::RequestBind:
        if (!oa->bind (_id, _repoid.c_str(), _tag, 0)) {
            orb->answer_bind (_id, CORBA::LocateUnknown,
                              CORBA::Object::_nil());
        }
        break;

    case CORBA::RequestLocate:
        oa->locate (_id, _obj);
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "queue.cc", 95, __PRETTY_FUNCTION__), 0)));
    }
}

void
MICO::ReqQueueRec::fail (CORBA::ObjectAdapter *oa, CORBA::ORB_ptr orb)
{
    switch (_type) {
    case CORBA::RequestInvoke: {
        CORBA::COMM_FAILURE ex (0, CORBA::COMPLETED_MAYBE);
        _request->set_out_args (&ex);
        orb->answer_invoke (_id, CORBA::InvokeSysEx,
                            CORBA::Object::_nil(), _request, 0);
        break;
    }
    case CORBA::RequestBind:
        orb->answer_bind (_id, CORBA::LocateUnknown,
                          CORBA::Object::_nil());
        break;

    case CORBA::RequestLocate:
        orb->answer_locate (_id, CORBA::LocateUnknown,
                            CORBA::Object::_nil(), 0);
        break;

    default:
        ((void) ((0) ? 0 : (__assert_fail ("0", "queue.cc", 121, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Object_ptr
MICO::ReqQueueRec::target ()
{
    return _obj;
}





MICO::RequestQueue::RequestQueue (CORBA::ObjectAdapter *oa,
                                  CORBA::ORB_ptr orb)
    : _oa (oa), _orb (orb), _current_id (0)
{
}

MICO::RequestQueue::~RequestQueue ()
{
    clear ();
    exec_stop ();
}

void
MICO::RequestQueue::add (ReqQueueRec *r)
{
    _invokes.push_back (r);
}

void
MICO::RequestQueue::exec_now ()
{

    set<MsgId, less<MsgId> > seen;
    while (_invokes.size() > 0) {
        ReqQueueRec *inv = _invokes.front();
        _current_id = inv->id();
        if (seen.count (_current_id))
            break;
        seen.insert (_current_id);
        _invokes.pop_front();




        inv->exec (_oa, _orb);
        delete inv;
    }
    _current_id = 0;
}

void
MICO::RequestQueue::exec_later ()
{

    if (_invokes.size() > 0) {
        _orb->dispatcher()->remove (this, CORBA::Dispatcher::Timer);
        _orb->dispatcher()->tm_event (this, 0 );
    }
}

void
MICO::RequestQueue::exec_stop ()
{
    _orb->dispatcher()->remove (this, CORBA::Dispatcher::Timer);
}

void
MICO::RequestQueue::fail ()
{

    int sz = _invokes.size();
    while (--sz >= 0 && _invokes.size() > 0) {
        ReqQueueRec *inv = _invokes.front();
        _invokes.pop_front();

        inv->fail (_oa, _orb);
        delete inv;
    }
}

void
MICO::RequestQueue::clear ()
{
    for (InvokeList::iterator i = _invokes.begin(); i != _invokes.end(); ++i)
        delete *i;
    _invokes.erase (_invokes.begin(), _invokes.end());
}

void
MICO::RequestQueue::callback (CORBA::Dispatcher *,
                              CORBA::DispatcherCallback::Event ev)
{
    if (ev == CORBA::Dispatcher::Timer)
        exec_now ();
}
# 26 "orb_all.cc" 2
# 1 "static.cc" 1
# 25 "static.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "static.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 27 "static.cc" 2
# 1 "../include/mico/throw.h" 1
# 28 "static.cc" 2
# 1 "../include/mico/util.h" 1
# 29 "static.cc" 2
# 1 "../include/mico/impl.h" 1
# 30 "static.cc" 2
# 1 "../include/mico/intercept.h" 1
# 31 "static.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 32 "static.cc" 2





CORBA::StaticTypeInfo::~StaticTypeInfo ()
{
}

CORBA::StaticValueType
CORBA::StaticTypeInfo::copy (const StaticValueType v) const
{
    StaticValueType nv = create();
    assign (nv, v);
    return nv;
}

CORBA::TypeCode_ptr
CORBA::StaticTypeInfo::typecode ()
{
    return CORBA::TypeCode::_nil();
}





CORBA::StaticAny::StaticAny (const StaticAny &a)
    : _info (a._info),
      _val (a._val ? a._info->copy (a._val) : 0),
      _dofree (1)
{
}

CORBA::StaticAny &
CORBA::StaticAny::operator= (const StaticAny &a)
{
    if (this != &a) {

        ((void) ((_info == a._info) ? 0 : (__assert_fail ("_info == a._info", "static.cc", 71, __PRETTY_FUNCTION__), 0)));
        if (_val) {
            if (a._val) {
                _info->assign (_val, a._val);
            } else {
                StaticValueType v = _info->create();
                _info->assign (_val, v);
                _info->free (v);
            }
        } else if (a._val) {
            _val = a._info->copy (a._val);
            _dofree = 1;
        }
    }
    return *this;
}

CORBA::StaticAny::~StaticAny ()
{
    if (_dofree && _val)
        _info->free (_val);
}

void
CORBA::StaticAny::value (StaticTypeInfo *info, ConstStaticValueType val,
                         CORBA::Boolean dofree)
{
    if (_dofree && _val)
        _info->free (_val);
    _info = info;
    _val = (StaticValueType)val;
    _dofree = dofree;
}

CORBA::StaticValueType
CORBA::StaticAny::_retn ()
{
    StaticValueType val = _val;
    _val = 0;
    return val;
}

CORBA::Boolean
CORBA::StaticAny::demarshal (CORBA::DataDecoder &dc)
{
    if (!_val) {
        _val = _info->create();
        _dofree = 1;
    }
    return _info->demarshal (dc, _val);
}

CORBA::Boolean
CORBA::StaticAny::marshal (CORBA::DataEncoder &ec)
{
    if (!_val) {
        _val = _info->create();
        _dofree = 1;
    }
    _info->marshal (ec, _val);
    return 1;
}





struct TCVoid : public CORBA::StaticTypeInfo {
    StaticValueType create () const
    { return 0; }
    StaticValueType copy (const StaticValueType v) const
    { return 0; }
    void assign (StaticValueType d, const StaticValueType s) const
    {}
    void free (StaticValueType v) const
    {}
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return 1; }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {}
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_void; }
};





class TCShort : public CORBA::StaticTypeInfo {
    typedef CORBA::Short _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_short (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_short (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_short; }
};





class TCLong : public CORBA::StaticTypeInfo {
    typedef CORBA::Long _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_long (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_long (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_long; }
};





class TCLongLong : public CORBA::StaticTypeInfo {
    typedef CORBA::LongLong _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_longlong (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_longlong (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_longlong; }
};





class TCUShort : public CORBA::StaticTypeInfo {
    typedef CORBA::UShort _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_ushort (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_ushort (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_ushort; }
};





class TCULong : public CORBA::StaticTypeInfo {
    typedef CORBA::ULong _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_ulong (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_ulong (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_ulong; }
};





class TCULongLong : public CORBA::StaticTypeInfo {
    typedef CORBA::ULongLong _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_ulonglong (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_ulonglong (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_ulonglong; }
};





class TCFloat : public CORBA::StaticTypeInfo {
    typedef CORBA::Float _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_float (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_float (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_float; }
};





class TCDouble : public CORBA::StaticTypeInfo {
    typedef CORBA::Double _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_double (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_double (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_double; }
};





class TCLongDouble : public CORBA::StaticTypeInfo {
    typedef CORBA::LongDouble _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v);}
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_longdouble (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_longdouble (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_longdouble; }
};





class TCChar : public CORBA::StaticTypeInfo {
    typedef CORBA::Char _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_char (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_char (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_char; }
};





class TCWChar : public CORBA::StaticTypeInfo {
    typedef CORBA::WChar _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_wchar (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_wchar (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_wchar; }
};





class TCOctet : public CORBA::StaticTypeInfo {
    typedef CORBA::Octet _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_octet (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_octet (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_octet; }
};





class TCBoolean : public CORBA::StaticTypeInfo {
    typedef CORBA::Boolean _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_boolean (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_boolean (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_boolean; }
};





class TCString : public CORBA::StaticTypeInfo {
    typedef char *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::string_dup (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::string_dup (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::string_free (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_string (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_string (*(_MICO_T *)v ? *(_MICO_T *)v : ""); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_string; }
};





class TCWString : public CORBA::StaticTypeInfo {
    typedef wchar_t *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::wstring_dup (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::wstring_dup (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::wstring_free (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_wstring (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_wstring (*(_MICO_T *)v ? *(_MICO_T *)v : L""); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_wstring; }
};





class TCAny : public CORBA::StaticTypeInfo {
    typedef CORBA::Any _MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    { return dc.get_any (*(_MICO_T *)v); }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    { ec.put_any (*(_MICO_T *)v); }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_any; }
};





class TCTypeCode : public CORBA::StaticTypeInfo {
    typedef CORBA::TypeCode *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::TypeCode::_duplicate (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::TypeCode::_duplicate (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::release (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        *(_MICO_T *)v = new CORBA::TypeCode;
        return dc.get_typecode (**(_MICO_T *)v);
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        if (*(_MICO_T *)v)
            ec.put_typecode (**(_MICO_T *)v);
        else {
            CORBA::TypeCode tc;
            ec.put_typecode (tc);
        }
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_TypeCode; }
};





class TCPrincipal : public CORBA::StaticTypeInfo {
    typedef CORBA::Principal *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::Principal::_duplicate (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::Principal::_duplicate (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::release (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        *(_MICO_T *)v = new CORBA::Principal;
        return dc.get_principal (**(_MICO_T *)v);
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        if (*(_MICO_T *)v)
            ec.put_principal (**(_MICO_T *)v);
        else {
            CORBA::Principal pr;
            ec.put_principal (pr);
        }
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_Principal; }
};





class TCContext : public CORBA::StaticTypeInfo {
    typedef CORBA::Context *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::Context::_duplicate (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::Context::_duplicate (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::release (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        *(_MICO_T *)v = new CORBA::Context ("");
        return dc.get_context (**(_MICO_T *)v);
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        if (*(_MICO_T *)v)
            ec.put_context (**(_MICO_T *)v);
        else {
            CORBA::Context ctx ("");
            ec.put_context (ctx);
        }
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_Context; }
};





class TCObject : public CORBA::StaticTypeInfo {
    typedef CORBA::Object *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::Object::_duplicate (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::Object::_duplicate (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::release (*(_MICO_T *)v); delete (_MICO_T *)v; }

    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::IOR *ior = new CORBA::IOR;
        if (!dc.get_ior (*ior)) {
            delete ior;
            return 0;
        }
        CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
        *(_MICO_T *)v = orb->ior_to_object (ior);
        return 1;
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        if (*(_MICO_T *)v) {





            ((void) (((*(_MICO_T *)v)->_ior()) ? 0 : (__assert_fail ("(*(_MICO_T *)v)->_ior()", "static.cc", 662, __PRETTY_FUNCTION__), 0)));
            ec.put_ior (*(*(_MICO_T *)v)->_ior());
        } else {
            CORBA::IOR ior;
            ec.put_ior (ior);
        }
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_Object; }
};





class TCValueBase : public CORBA::StaticTypeInfo {
    typedef CORBA::ValueBase *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { CORBA::add_ref (*(_MICO_T *)v); return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { CORBA::add_ref (*(_MICO_T *)s); *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { CORBA::remove_ref (*(_MICO_T *)v); delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        return CORBA::ValueBase::_demarshal (
            dc, *(_MICO_T *)v, "IDL:omg.org/CORBA/ValueBase:1.0");
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_ValueBase; }
};





class TCAbstractBase : public CORBA::StaticTypeInfo {
    typedef CORBA::AbstractBase *_MICO_T;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T (0); }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (CORBA::AbstractBase::_duplicate (*(_MICO_T *)v)); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = CORBA::AbstractBase::_duplicate (*(_MICO_T *)s); }
    void free (StaticValueType v) const
    { CORBA::release (*(_MICO_T *)v); delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        return CORBA::AbstractBase::_demarshal (dc, *(_MICO_T *)v);
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::AbstractBase::_marshal (ec, *(_MICO_T *)v);
    }
    CORBA::TypeCode_ptr typecode ()
    { return CORBA::_tc_AbstractBase; }
};





class TCSeqShort : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Short,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_shorts (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_shorts (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_short)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqShort::_tc = 0;




class TCSeqLong : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Long,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_longs (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_longs (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_long)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqLong::_tc = 0;





class TCSeqLongLong : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::LongLong,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_longlongs (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_longlongs (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_longlong)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqLongLong::_tc = 0;





class TCSeqUShort : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::UShort,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_ushorts (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_ushorts (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_ushort)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqUShort::_tc = 0;





class TCSeqULong : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::ULong,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_ulongs (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_ulongs (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_ulong)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqULong::_tc = 0;





class TCSeqULongLong : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::ULongLong,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_ulonglongs (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_ulonglongs (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_ulonglong)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqULongLong::_tc = 0;





class TCSeqFloat : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Float,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_floats (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_floats (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_float)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqFloat::_tc = 0;





class TCSeqDouble : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Double,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_doubles (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_doubles (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_double)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqDouble::_tc = 0;





class TCSeqLongDouble : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::LongDouble,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_longdoubles (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_longdoubles (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc(0, CORBA::_tc_longdouble)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqLongDouble::_tc = 0;





class TCSeqChar : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Char,2> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_chars ((CORBA::Char *)&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_chars ((CORBA::Char *)&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_char)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqChar::_tc = 0;





class TCSeqWChar : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::WChar,4> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_wchars (&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_wchars (&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_wchar)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqWChar::_tc = 0;





class TCSeqBoolean : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Boolean,1> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_booleans ((CORBA::Boolean *)&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_booleans ((CORBA::Boolean *)&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_boolean)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqBoolean::_tc = 0;





class TCSeqAny : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Any,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!dc.get_any ((*(_MICO_T *)v)[i]))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            ec.put_any ((*(_MICO_T *)v)[i]);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_any)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqAny::_tc = 0;





class TCSeqOctet : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Octet,3> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        if (len > 0) {
            if (!dc.get_octets ((CORBA::Octet *)&(*(_MICO_T *)v)[0], len))
                return 0;
        }
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        if (len > 0)
            ec.put_octets ((CORBA::Octet *)&(*(_MICO_T *)v)[0], len);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_octet)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqOctet::_tc = 0;





class TCSeqString : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::String_var,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!dc.get_string ((*(_MICO_T *)v)[i].out()))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            ec.put_string ((*(_MICO_T *)v)[i]);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_string)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqString::_tc = 0;





class TCSeqWString : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::WString_var,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!dc.get_wstring ((*(_MICO_T *)v)[i].out()))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            ec.put_wstring ((*(_MICO_T *)v)[i]);
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_wstring)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqWString::_tc = 0;





class TCSeqObject : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::Object_var,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!CORBA::_stc_Object->demarshal (dc, &((*(_MICO_T *)v)[i])._for_demarshal()))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            CORBA::_stc_Object->marshal (ec, &((*(_MICO_T *)v)[i]).inout());
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_Object)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqObject::_tc = 0;





class TCSeqValueBase : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::ValueBase_var,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!CORBA::_stc_ValueBase->demarshal (dc, &((*(_MICO_T*)v)[i])._for_demarshal()))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            CORBA::_stc_ValueBase->marshal (ec, &((*(_MICO_T *)v)[i]).inout());
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_ValueBase)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqValueBase::_tc = 0;





class TCSeqAbstractBase : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<CORBA::AbstractBase_var,0> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
public:
    StaticValueType create () const
    { return (StaticValueType)new _MICO_T; }
    StaticValueType copy (const StaticValueType v) const
    { return (StaticValueType)new _MICO_T (*(_MICO_T *)v); }
    void assign (StaticValueType d, const StaticValueType s) const
    { *(_MICO_T *)d = *(_MICO_T *)s; }
    void free (StaticValueType v) const
    { delete (_MICO_T *)v; }
    CORBA::Boolean demarshal (CORBA::DataDecoder &dc, StaticValueType v) const
    {
        CORBA::ULong len;
        if (!dc.seq_begin (len))
            return 0;
        ((_MICO_T *)v)->length (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            if (!CORBA::_stc_AbstractBase->demarshal (dc, &((*(_MICO_T*)v)[i])._for_demarshal()))
                return 0;
        return dc.seq_end();
    }
    void marshal (CORBA::DataEncoder &ec, StaticValueType v) const
    {
        CORBA::ULong len = ((_MICO_T *)v)->length();
        ec.seq_begin (len);
        for (CORBA::ULong i = 0; i < len; ++i)
            CORBA::_stc_AbstractBase->marshal (ec, &((*(_MICO_T *)v)[i]).inout());
        ec.seq_end ();
    }
    CORBA::TypeCode_ptr typecode ()
    {
        if (!_tc)
            _tc = CORBA::TypeCode::create_sequence_tc (0, CORBA::_tc_AbstractBase)
                ->mk_constant();
        return _tc;
    }
};
CORBA::TypeCode_ptr TCSeqAbstractBase::_tc = 0;






namespace CORBA {
    CORBA::StaticTypeInfo *_stc_void;
    CORBA::StaticTypeInfo *_stc_short;
    CORBA::StaticTypeInfo *_stc_long;
    CORBA::StaticTypeInfo *_stc_longlong;
    CORBA::StaticTypeInfo *_stc_ushort;
    CORBA::StaticTypeInfo *_stc_ulong;
    CORBA::StaticTypeInfo *_stc_ulonglong;
    CORBA::StaticTypeInfo *_stc_float;
    CORBA::StaticTypeInfo *_stc_double;
    CORBA::StaticTypeInfo *_stc_longdouble;
    CORBA::StaticTypeInfo *_stc_char;
    CORBA::StaticTypeInfo *_stc_wchar;
    CORBA::StaticTypeInfo *_stc_octet;
    CORBA::StaticTypeInfo *_stc_boolean;
    CORBA::StaticTypeInfo *_stc_string;
    CORBA::StaticTypeInfo *_stc_wstring;
    CORBA::StaticTypeInfo *_stc_any;
    CORBA::StaticTypeInfo *_stc_TypeCode;
    CORBA::StaticTypeInfo *_stc_Principal;
    CORBA::StaticTypeInfo *_stc_Context;
    CORBA::StaticTypeInfo *_stc_Object;
    CORBA::StaticTypeInfo *_stc_ValueBase;
    CORBA::StaticTypeInfo *_stc_AbstractBase;
    CORBA::StaticTypeInfo *_stcseq_short;
    CORBA::StaticTypeInfo *_stcseq_long;
    CORBA::StaticTypeInfo *_stcseq_longlong;
    CORBA::StaticTypeInfo *_stcseq_ushort;
    CORBA::StaticTypeInfo *_stcseq_ulong;
    CORBA::StaticTypeInfo *_stcseq_ulonglong;
    CORBA::StaticTypeInfo *_stcseq_float;
    CORBA::StaticTypeInfo *_stcseq_double;
    CORBA::StaticTypeInfo *_stcseq_longdouble;
    CORBA::StaticTypeInfo *_stcseq_char;
    CORBA::StaticTypeInfo *_stcseq_wchar;
    CORBA::StaticTypeInfo *_stcseq_octet;
    CORBA::StaticTypeInfo *_stcseq_boolean;
    CORBA::StaticTypeInfo *_stcseq_any;
    CORBA::StaticTypeInfo *_stcseq_string;
    CORBA::StaticTypeInfo *_stcseq_wstring;
    CORBA::StaticTypeInfo *_stcseq_Object;
    CORBA::StaticTypeInfo *_stcseq_ValueBase;
    CORBA::StaticTypeInfo *_stcseq_AbstractBase;
};
# 1689 "static.cc"
static struct InitStaticTypeInfo {
    InitStaticTypeInfo()
    {
        CORBA::_stc_void = new TCVoid;
        CORBA::_stc_short = new TCShort;
        CORBA::_stc_long = new TCLong;
        CORBA::_stc_longlong = new TCLongLong;
        CORBA::_stc_ushort = new TCUShort;
        CORBA::_stc_ulong = new TCULong;
        CORBA::_stc_ulonglong = new TCULongLong;
        CORBA::_stc_float = new TCFloat;
        CORBA::_stc_double = new TCDouble;
        CORBA::_stc_longdouble = new TCLongDouble;
        CORBA::_stc_char = new TCChar;
        CORBA::_stc_wchar = new TCWChar;
        CORBA::_stc_octet = new TCOctet;
        CORBA::_stc_boolean = new TCBoolean;
        CORBA::_stc_string = new TCString;
        CORBA::_stc_wstring = new TCWString;
        CORBA::_stc_any = new TCAny;
        CORBA::_stc_TypeCode = new TCTypeCode;
        CORBA::_stc_Principal = new TCPrincipal;
        CORBA::_stc_Context = new TCContext;
        CORBA::_stc_Object = new TCObject;
        CORBA::_stc_ValueBase = new TCValueBase;
        CORBA::_stc_AbstractBase = new TCAbstractBase;
        CORBA::_stcseq_short = new TCSeqShort;
        CORBA::_stcseq_long = new TCSeqLong;
        CORBA::_stcseq_longlong = new TCSeqLongLong;
        CORBA::_stcseq_ushort = new TCSeqUShort;
        CORBA::_stcseq_ulong = new TCSeqULong;
        CORBA::_stcseq_ulonglong = new TCSeqULongLong;
        CORBA::_stcseq_float = new TCSeqFloat;
        CORBA::_stcseq_double = new TCSeqDouble;
        CORBA::_stcseq_longdouble = new TCSeqLongDouble;
        CORBA::_stcseq_char = new TCSeqChar;
        CORBA::_stcseq_wchar = new TCSeqWChar;
        CORBA::_stcseq_octet = new TCSeqOctet;
        CORBA::_stcseq_boolean = new TCSeqBoolean;
        CORBA::_stcseq_any = new TCSeqAny;
        CORBA::_stcseq_string = new TCSeqString;
        CORBA::_stcseq_wstring = new TCSeqWString;
        CORBA::_stcseq_Object = new TCSeqObject;
        CORBA::_stcseq_ValueBase = new TCSeqValueBase;
        CORBA::_stcseq_AbstractBase = new TCSeqAbstractBase;
    }
} __init_static_type_info;





CORBA::StaticRequest::StaticRequest (CORBA::Object_ptr obj, const char *opname)
{
    if (!obj->_ior())

        mico_throw (NO_IMPLEMENT());

    _msgid = 0;
    _opname = opname;
    _res = 0;
    _ctx = 0;
    _env = 0;
    _ctx_list = 0;
    _obj = CORBA::Object::_duplicate (obj);

    _iceptreq = Interceptor::ClientInterceptor::_create_request (
        _obj, _opname, *context(), CORBA::Request::_nil());
}

CORBA::StaticRequest::~StaticRequest ()
{
    if (_msgid)
        _obj->_orbnc()->cancel (_msgid);
    CORBA::release (_ctx);
    CORBA::release (_env);
    CORBA::release (_ctx_list);
    CORBA::release (_iceptreq);
}

const char *
CORBA::StaticRequest::op_name()
{
    return _opname;
}

CORBA::Boolean
CORBA::StaticRequest::copy (StaticAnyList *dst, StaticAnyList *src,
                            CORBA::Flags f)
{
    int dst_count = dst->size();
    int src_count = src->size();

    StaticAny *dst_any, *src_any;
    for (int d = 0, s = 0;; ++d, ++s) {
        dst_any = 0;
        for ( ; d < dst_count; ++d) {
            dst_any = (*dst)[d];
            if (dst_any->flags() & f)
                break;
        }
        src_any = 0;
        for ( ; s < src_count; ++s) {
            src_any = (*src)[s];
            if (src_any->flags() & f)
                break;
        }
        if (s >= src_count || d >= dst_count) {

            if (!(s >= src_count && d >= dst_count))
                return 0;
            break;
        }

        if (!((src_any->flags() & f) == (dst_any->flags() & f)))
            return 0;


        *dst_any = *src_any;
    }
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::get_in_args (NVList_ptr iparams, Context_ptr &ctx)
{
    if (iparams->count() != _args.size())
        return 0;

    CORBA::NamedValue_ptr nv;
    for (mico_vec_size_type i0 = 0; i0 < _args.size(); ++i0) {
        nv = iparams->item (i0);
        if (_args[i0]->flags() != nv->flags())
            return 0;
        if (_args[i0]->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            nv->value()->from_static_any (*_args[i0]);
        }
    }
    ctx = CORBA::Context::_duplicate (_ctx);
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::get_in_args (StaticAnyList *iparams,
                                   CORBA::Context_ptr &ctx)
{
    if (!copy (iparams, &_args, CORBA::ARG_IN|CORBA::ARG_INOUT))
        return 0;
    ctx = CORBA::Context::_duplicate (_ctx);
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::get_in_args (DataEncoder *ec)
{
    if (_args.size() == 0 && CORBA::is_nil (_ctx))
        return 1;


    CORBA::DataEncoder::ValueState vstate;
    ec->valuestate (&vstate, 0);

    for (mico_vec_size_type i = 0; i < _args.size(); ++i) {
        if (_args[i]->flags() & (CORBA::ARG_IN|CORBA::ARG_INOUT)) {
            if (!_args[i]->marshal (*ec))
                return 0;
        }
    }

    if (!CORBA::is_nil (_ctx))
        ec->put_context (*_ctx, _ctx_list);

    ec->valuestate (0);

    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::get_out_args (Any *res, NVList_ptr oparams,
                                    Exception *&ex)
{
    CORBA::Exception *e = exception();
    if (e) {
        ex = e->_clone();
        return 1;
    }

    if (oparams->count() != _args.size())
        return 0;

    if (res && _res) {
        res->from_static_any (*_res);
    }

    CORBA::NamedValue_ptr nv;
    for (mico_vec_size_type i0 = 0; i0 < _args.size(); ++i0) {
        nv = oparams->item(i0);
        if (_args[i0]->flags() != nv->flags())
            return 0;
        if (_args[i0]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            nv->value()->from_static_any (*_args[i0]);
        }
    }
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::get_out_args (CORBA::StaticAny *res,
                                    StaticAnyList *oparams,
                                    CORBA::Exception *&ex)
{
    CORBA::Exception *e = exception();
    if (e) {
        ex = e->_clone();
        return 1;
    }
    if (res && _res)
        *res = *_res;
    return copy (oparams, &_args, CORBA::ARG_OUT|CORBA::ARG_INOUT);
}

CORBA::Boolean
CORBA::StaticRequest::get_out_args (DataEncoder *ec, Boolean &is_except)
{
    is_except = 0;
    CORBA::Exception *e = exception();

    if (!e && !_res && _args.size() == 0)
        return 1;


    CORBA::DataEncoder::ValueState vstate;
    ec->valuestate (&vstate, 0);

    if (e) {
        is_except = 1;
        e->_encode (*ec);
        return 1;
    }

    if (_res) {
        if (!_res->marshal (*ec))
            return 0;
    }
    for (mico_vec_size_type i = 0; i < _args.size(); ++i) {
        if (_args[i]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            if (!_args[i]->marshal (*ec))
                return 0;
        }
    }
    ec->valuestate (0);

    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::set_out_args (Any *res, NVList_ptr oparams)
{
    if (oparams->count() != _args.size())
        return 0;

    if (res && _res) {
        if (!res->to_static_any (*_res))
            return 0;
    }

    CORBA::NamedValue_ptr nv;
    for (mico_vec_size_type i0 = 0; i0 < _args.size(); ++i0) {
        nv = oparams->item(i0);
        if (_args[i0]->flags() != nv->flags())
            return 0;
        if (_args[i0]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
            if (!nv->value()->to_static_any (*_args[i0]))
                return 0;
        }
    }
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::set_out_args (CORBA::StaticAny *res,
                                    StaticAnyList *oparams)
{
    if (res && _res)
        *_res = *res;
    return copy (&_args, oparams, CORBA::ARG_OUT|CORBA::ARG_INOUT);
}

void
CORBA::StaticRequest::set_out_args (Exception *ex)
{
    exception (ex->_clone());
}

CORBA::Boolean
CORBA::StaticRequest::set_out_args (CORBA::DataDecoder *dc,
                                    CORBA::Boolean is_ex)
{
    if (!is_ex && !_res && _args.size() == 0)
        return 1;

    CORBA::Boolean ret;


    CORBA::DataDecoder::ValueState vstate;
    dc->valuestate (&vstate, 0);

    if (is_ex) {
        CORBA::Exception *e = CORBA::Exception::_decode (*dc);
        ((void) ((e) ? 0 : (__assert_fail ("e", "static.cc", 1998, __PRETTY_FUNCTION__), 0)));
        exception (e);
    } else {
        if (_res) {
            ret = _res->demarshal (*dc);
            if (!ret) {
                dc->valuestate (0);
                return 0;
            }
        }
        for (mico_vec_size_type i = 0; i < _args.size(); ++i) {
            if (_args[i]->flags() & (CORBA::ARG_OUT|CORBA::ARG_INOUT)) {
                ret = _args[i]->demarshal (*dc);
                if (!ret) {
                    dc->valuestate (0);
                    return 0;
                }
            }
        }
    }
    dc->valuestate (0);
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::copy_out_args (ORBRequest *r)
{
    if (this == r)
        return 1;


    copy_svc (r);

    CORBA::Exception *ex;
    if (!r->get_out_args (_res, &_args, ex))
        return 0;
    if (ex)
        exception (ex);
    return 1;
}

CORBA::Boolean
CORBA::StaticRequest::copy_in_args (ORBRequest *r)
{
    ((void) ((0) ? 0 : (__assert_fail ("0", "static.cc", 2042, __PRETTY_FUNCTION__), 0)));
    return 0;
}

const char *
CORBA::StaticRequest::type ()
{
    return "static";
}

void
CORBA::StaticRequest::add_in_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_IN);
}

void
CORBA::StaticRequest::add_out_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_OUT);
}

void
CORBA::StaticRequest::add_inout_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_INOUT);
}

void
CORBA::StaticRequest::set_context (CORBA::Context_ptr ctx)
{
    _ctx = CORBA::Context::_duplicate (ctx);
}

void
CORBA::StaticRequest::set_context_list (CORBA::ContextList_ptr ctx_list)
{
    _ctx_list = CORBA::ContextList::_duplicate (ctx_list);
}

CORBA::Exception *
CORBA::StaticRequest::exception ()
{
    if (CORBA::is_nil (_env))
        return 0;
    return _env->exception();
}

void
CORBA::StaticRequest::exception (CORBA::Exception *e)
{
    if (CORBA::is_nil (_env))
        _env = new CORBA::Environment;
    _env->exception (e);
}

CORBA::Environment_ptr
CORBA::StaticRequest::env ()
{
    if (CORBA::is_nil (_env))
        _env = new CORBA::Environment;
    return _env;
}

void
CORBA::StaticRequest::invoke ()
{
    CORBA::ORB_ptr orb = _obj->_orbnc();
    CORBA::Object_var obj;
    CORBA::ORBRequest *dummy;
    CORBA::Boolean done = 0;
    CORBA::ULong msgid;


    ((void) ((!_msgid) ? 0 : (__assert_fail ("!_msgid", "static.cc", 2119, __PRETTY_FUNCTION__), 0)));

    if (_iceptreq && !Interceptor::ClientInterceptor::
        _exec_initialize_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  env())) {
        return;
    }

    msgid = orb->invoke_async (_obj, this, CORBA::Principal::_nil());

    if (_iceptreq && !Interceptor::ClientInterceptor::
        _exec_after_marshal ((Interceptor::LWRequest_ptr)_iceptreq,
                             env())) {
        orb->cancel (msgid);
        return;
    }
    while (!done) {
        CORBA::Boolean ret = orb->wait (msgid);
        ((void) ((ret) ? 0 : (__assert_fail ("ret", "static.cc", 2137, __PRETTY_FUNCTION__), 0)));


        if (_iceptreq && !Interceptor::ClientInterceptor::
            _exec_before_unmarshal ((Interceptor::LWRequest_ptr)_iceptreq,
                                    env())) {
            orb->cancel (msgid);
            return;
        }

        CORBA::GIOP::AddressingDisposition ad;
        CORBA::InvokeStatus rs = orb->get_invoke_reply (msgid, obj, dummy, ad);
        switch (rs) {
        case CORBA::InvokeForward:

            ((void) ((_obj.in() && obj.in()) ? 0 : (__assert_fail ("_obj.in() && obj.in()", "static.cc", 2152, __PRETTY_FUNCTION__), 0)));
            _obj->_forward (obj);
            msgid = orb->invoke_async (_obj, this, Principal::_nil());
            break;

        case CORBA::InvokeAddrDisp:
          _obj->_ior_fwd()->addressing_disposition (ad);
          msgid = orb->invoke_async (_obj, this, Principal::_nil());
          break;

        case CORBA::InvokeOk:
        case CORBA::InvokeUsrEx:
            done = 1;
            break;

        case CORBA::InvokeSysEx:
            if (_obj->_is_forwarded()) {
# 2181 "static.cc"
                CORBA::SystemException *sysex =
                    CORBA::SystemException::_downcast (exception());
                ((void) ((sysex) ? 0 : (__assert_fail ("sysex", "static.cc", 2183, __PRETTY_FUNCTION__), 0)));
                if (sysex->completed() == CORBA::COMPLETED_NO &&
                    (CORBA::COMM_FAILURE::_downcast (sysex) ||
                     CORBA::TRANSIENT::_downcast (sysex) ||
                     CORBA::OBJECT_NOT_EXIST::_downcast (sysex))) {
                    _obj->_unforward();
                    env()->clear();
                    msgid = orb->invoke_async (_obj, this,
                                               Principal::_nil());
                    break;
                }
            }
            done = 1;
            break;

        default:
            ((void) ((0) ? 0 : (__assert_fail ("0", "static.cc", 2199, __PRETTY_FUNCTION__), 0)));
        }
    }

    if (_iceptreq) {
        Interceptor::ClientInterceptor::
            _exec_finish_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  env());
    }
}

void
CORBA::StaticRequest::oneway ()
{
    if (_iceptreq && !Interceptor::ClientInterceptor::
        _exec_initialize_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  env())) {
        return;
    }
    _obj->_orbnc()->invoke_async (_obj, this, CORBA::Principal::_nil(), 0);

    if (_iceptreq) {
        Interceptor::ClientInterceptor::
            _exec_after_marshal ((Interceptor::LWRequest_ptr)_iceptreq,
                                 env());
    }
}

void
CORBA::StaticRequest::send_deferred ()
{
    CORBA::ORB_ptr orb = _obj->_orbnc();

    if (_iceptreq && !Interceptor::ClientInterceptor::
        _exec_initialize_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  env())) {
        _msgid = 0;
        return;
    }

    _msgid = orb->invoke_async (_obj, this, CORBA::Principal::_nil());

    if (_iceptreq && !Interceptor::ClientInterceptor::
        _exec_after_marshal ((Interceptor::LWRequest_ptr)_iceptreq,
                             env())) {
        orb->cancel (_msgid);
        _msgid = 0;
    }
}

void
CORBA::StaticRequest::get_response ()
{
    CORBA::ORB_ptr orb = _obj->_orbnc();
    CORBA::Object_var obj;
    CORBA::ORBRequest *dummy;
    CORBA::Boolean done = 0;
    CORBA::GIOP::AddressingDisposition ad;

    ((void) ((_msgid) ? 0 : (__assert_fail ("_msgid", "static.cc", 2258, __PRETTY_FUNCTION__), 0)));

    while (!done) {
        CORBA::Boolean ret = orb->wait (_msgid);
        ((void) ((ret) ? 0 : (__assert_fail ("ret", "static.cc", 2262, __PRETTY_FUNCTION__), 0)));


        if (_iceptreq && !Interceptor::ClientInterceptor::
            _exec_before_unmarshal ((Interceptor::LWRequest_ptr)_iceptreq,
                                    env())) {
            orb->cancel (_msgid);
            _msgid = 0;
            return;
        }

        CORBA::InvokeStatus rs = orb->get_invoke_reply (_msgid, obj,
                                                        dummy, ad);
        switch (rs) {
        case CORBA::InvokeForward:

            ((void) ((_obj.in() && obj.in()) ? 0 : (__assert_fail ("_obj.in() && obj.in()", "static.cc", 2278, __PRETTY_FUNCTION__), 0)));
            _obj->_forward (obj);
            _msgid = orb->invoke_async (obj, this, Principal::_nil());
            break;

        case CORBA::InvokeAddrDisp:
          _obj->_ior_fwd()->addressing_disposition (ad);
          _msgid = orb->invoke_async (_obj, this, Principal::_nil());
          break;

        case CORBA::InvokeOk:
        case CORBA::InvokeUsrEx:
            done = 1;
            break;

        case CORBA::InvokeSysEx:
            if (_obj->_is_forwarded()) {
# 2307 "static.cc"
                CORBA::SystemException *sysex =
                    CORBA::SystemException::_downcast (exception());
                ((void) ((sysex) ? 0 : (__assert_fail ("sysex", "static.cc", 2309, __PRETTY_FUNCTION__), 0)));
                if (sysex->completed() == CORBA::COMPLETED_NO &&
                    (CORBA::COMM_FAILURE::_downcast (sysex) ||
                     CORBA::TRANSIENT::_downcast (sysex) ||
                     CORBA::OBJECT_NOT_EXIST::_downcast (sysex))) {
                    _obj->_unforward();
                    env()->clear();
                    _msgid = orb->invoke_async (_obj, this,
                                               Principal::_nil());
                    break;
                }
            }
            done = 1;
            break;

        default:
            ((void) ((0) ? 0 : (__assert_fail ("0", "static.cc", 2325, __PRETTY_FUNCTION__), 0)));
        }
    }

    if (_iceptreq) {
        Interceptor::ClientInterceptor::
            _exec_finish_request ((Interceptor::LWRequest_ptr)_iceptreq,
                                  env());
    }
    _msgid = 0;
}





CORBA::StaticImplementation::StaticImplementation ()
{
}

CORBA::StaticImplementation::~StaticImplementation ()
{
}

CORBA::ServerRequestBase_ptr
CORBA::StaticImplementation::make_request (ORBRequest *req,
                                           CORBA::Object_ptr obj,
                                           CORBA::ULong msgid,
                                           CORBA::ObjectAdapter *oa,
                                           CORBA::Principal_ptr pr)
{
    return new StaticServerRequest (req, obj, msgid, oa, pr);
}

void
CORBA::StaticImplementation::doinvoke (ServerRequestBase_ptr req,
                                       Environment &env)
{
    invoke ((StaticServerRequest_ptr)req, env);
}





CORBA::StaticServerRequest::StaticServerRequest (ORBRequest *req,
                                                 Object_ptr obj, MsgId msgid,
                                                 CORBA::ObjectAdapter *oa,
                                                 CORBA::Principal_ptr pr)
    : _oa (oa), _obj (Object::_duplicate (obj)),
      _ctx (Context::_nil()), _env (pr),
      _req (ORBRequest::_duplicate (req)),
      _res (0), _msgid (msgid), _aborted (0)
{
    _iceptreq = Interceptor::ServerInterceptor::_create_request (
        _obj, req->op_name(), *req->context(), CORBA::ServerRequest::_nil());
}

CORBA::StaticServerRequest::~StaticServerRequest ()
{
    if (!_canceled) {

        CORBA::InvokeStatus stat = CORBA::InvokeOk;
        if (_env.exception()) {
            if (CORBA::SystemException::_downcast (_env.exception())) {
                stat = CORBA::InvokeSysEx;
            } else {
                stat = CORBA::InvokeUsrEx;
            }
        }
        _oa->answer_invoke (_msgid, _obj, _req, stat);

        if (_iceptreq && !_aborted && !Interceptor::ServerInterceptor::
            _exec_finish_request ((Interceptor::LWServerRequest_ptr)_iceptreq,
                                  &_env)) {

        }
    }

    CORBA::release (_obj);
    CORBA::release (_ctx);
    CORBA::release (_req);
    CORBA::release (_iceptreq);
}

void
CORBA::StaticServerRequest::add_in_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_IN);
}

void
CORBA::StaticServerRequest::add_out_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_OUT);
}

void
CORBA::StaticServerRequest::add_inout_arg (StaticAny *a)
{
    _args.push_back (a);
    a->flags (CORBA::ARG_INOUT);
}

CORBA::Boolean
CORBA::StaticServerRequest::read_args ()
{





    if (_iceptreq && !Interceptor::ServerInterceptor::
        _exec_initialize_request ((Interceptor::LWServerRequest_ptr)_iceptreq,
                                  &_env)) {
        _aborted = 1;
        write_results ();
        return 0;
    }

    if (!_req->get_in_args (&_args, _ctx)) {
        if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
          MICO::Logger::Stream (MICO::Logger::Error)
            << "Error: cannot decode args in StaticServerRequest" << endl;
        }
        _aborted = 1;
        set_exception (new CORBA::MARSHAL());
        write_results ();
        return 0;
    }

    if (_iceptreq && !Interceptor::ServerInterceptor::
        _exec_after_unmarshal ((Interceptor::LWServerRequest_ptr)_iceptreq,
                               &_env)) {
        _aborted = 1;
        write_results ();
        return 0;
    }
    return 1;
}

void
CORBA::StaticServerRequest::write_results ()
{

    _req->context()->length (0);






    if (_iceptreq && !_aborted && !Interceptor::ServerInterceptor::
        _exec_before_marshal ((Interceptor::LWServerRequest_ptr)_iceptreq,
                              &_env)) {
        _aborted = 1;
    }

    if (_env.exception()) {
        _req->set_out_args (_env.exception());
    } else {
        if (!_req->set_out_args (_res, &_args)) {
          if (MICO::Logger::IsLogged (MICO::Logger::Error)) {
            MICO::Logger::Stream (MICO::Logger::Error)
              << "Error: cannot set out args in StaticServerRequest" << endl;
          }
          CORBA::MARSHAL ex (0, CORBA::COMPLETED_YES);
          _req->set_out_args (&ex);
        }
    }
}
# 27 "orb_all.cc" 2
# 1 "intercept.cc" 1
# 25 "intercept.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "intercept.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 27 "intercept.cc" 2
# 1 "../include/mico/throw.h" 1
# 28 "intercept.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 29 "intercept.cc" 2


template<class T>
static inline void
insert_interceptor (list<T> &l, T ic)
{
    typename list<T>::iterator i = l.end();
    if (l.size() > 0) {
        do {
            --i;
            if (ic->prio() < (*i)->prio()) {
                ++i;
                break;
            }
        } while (i != l.begin());
    }
    l.insert (i, ic);
}

template<class T>
static inline
void remove_interceptor (list<T> &l, T ic)
{
    for (typename list<T>::iterator i = l.begin(); i != l.end(); ++i) {
        if (*i == ic) {
            l.erase (i);
            break;
        }
    }
}





Interceptor::Root::Root ()
{
    _prio = 0;
    _is_active = 0;
}

Interceptor::Root::Root (Priority p)
{
    _prio = p;
    _is_active = 1;
}

Interceptor::Root::~Root ()
{
}

const char *
Interceptor::Root::_repoid() const
{
    return "IDL:omg.org/Interceptor/Root:1.0";
}

Interceptor::Root_ptr
Interceptor::Root::_narrow (Root_ptr _obj)
{
    return _duplicate (_obj);
}

Interceptor::Root::Priority
Interceptor::Root::prio()
{
    return _prio;
}

void
Interceptor::Root::activate (Priority p)
{
    _prio = p;
    _is_active = 1;
}

void
Interceptor::Root::deactivate ()
{
    _is_active = 0;
}

CORBA::Boolean
Interceptor::Root::is_active ()
{
    return _is_active;
}





Interceptor::Context::Context ()
{
}

Interceptor::Context::~Context ()
{
}

const char *
Interceptor::Context::_repoid() const
{
    return "IDL:omg.org/Interceptor/Context:1.0";
}

Interceptor::Context_ptr
Interceptor::Context::_narrow (Context_ptr _obj)
{
    return _duplicate (_obj);
}

void Interceptor::Context::destroy ()
{

    CORBA::release (this);
}





Interceptor::LWRootRequest::LWRootRequest (
    CORBA::Object_var &obj,
    CORBA::String_var &op,
    CORBA::IOP::ServiceContextList &svc)
    : _svc (svc), _op (op), _obj (obj)
{
}

Interceptor::LWRootRequest::~LWRootRequest ()
{
}

const char *
Interceptor::LWRootRequest::_repoid() const
{
    return "IDL:omg.org/Interceptor/LWRootRequest:1.0";
}

Interceptor::LWRootRequest_ptr
Interceptor::LWRootRequest::_narrow (LWRootRequest_ptr _obj)
{
    return _duplicate (_obj);
}

CORBA::Object_ptr
Interceptor::LWRootRequest::target()
{
    return CORBA::Object::_duplicate ((CORBA::Object_ptr)_obj);
}

void
Interceptor::LWRootRequest::target (CORBA::Object_ptr obj)
{
    _obj = CORBA::Object::_duplicate (obj);
}

CORBA::Identifier
Interceptor::LWRootRequest::operation()
{
    return CORBA::string_dup (_op);
}

void
Interceptor::LWRootRequest::operation (const CORBA::Identifier op)
{
    _op = CORBA::string_dup (op);
}

void
Interceptor::LWRootRequest::set_service_context (ServiceID id,
                                                 CORBA::Long flags,
                                                 const ContextData &d)
{
    for (CORBA::ULong i = 0; i < _svc.length(); ++i) {
        if (_svc[i].context_id == id) {
            if (flags )
                mico_throw (CORBA::NO_PERMISSION());
            _svc[i].context_data = d;
            return;
        }
    }
    CORBA::ULong l = _svc.length();
    _svc.length (l+1);
    _svc[l].context_id = id;
    _svc[l].context_data = d;
}

Interceptor::ContextData *
Interceptor::LWRootRequest::get_service_context (ServiceID id,
                                                 CORBA::Long flags)
{
    for (CORBA::ULong i = 0; i < _svc.length(); ++i) {
        if (_svc[i].context_id == id)
            return new ContextData (_svc[i].context_data);
    }
    mico_throw (CORBA::BAD_PARAM());
    return 0;
}

void
Interceptor::LWRootRequest::remove_service_context (ServiceID id)
{
    for (CORBA::ULong i = 0; i < _svc.length(); ++i) {
        if (_svc[i].context_id == id) {
            if (i != _svc.length()-1)
                _svc[i] = _svc[_svc.length()-1];
            _svc.length (_svc.length()-1);
            return;
        }
    }
}

CORBA::Boolean
Interceptor::LWRootRequest::has_service_context (ServiceID id)
{
    for (CORBA::ULong i = 0; i < _svc.length(); ++i) {
        if (_svc[i].context_id == id)
            return 1;
    }
    return 0;
}

void
Interceptor::LWRootRequest::set_context (Root_ptr interceptor,
                                         Context_ptr ctx)
{
    _ctxs[interceptor] = Context::_duplicate (ctx);
}

Interceptor::Context_ptr
Interceptor::LWRootRequest::get_context (Root_ptr interceptor)
{
    return Context::_duplicate (_ctxs[interceptor]);
}





Interceptor::LWRequest::LWRequest (
    CORBA::Object_var &obj,
    CORBA::String_var &op,
    CORBA::IOP::ServiceContextList &svc,
    CORBA::Request_ptr req)
    : Interceptor::LWRootRequest (obj, op, svc), _req (req)
{
}

Interceptor::LWRequest::~LWRequest ()
{
}

const char *
Interceptor::LWRequest::_repoid() const
{
    return "IDL:omg.org/Interceptor/LWRequest:1.0";
}

Interceptor::LWRequest_ptr
Interceptor::LWRequest::_narrow (LWRootRequest_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(), "IDL:omg.org/Interceptor/LWRequest:1.0"))
        return _duplicate ((LWRequest_ptr)_obj);
    return _nil();
}

CORBA::Request_ptr
Interceptor::LWRequest::request ()
{
    return CORBA::Request::_duplicate (_req);
}





Interceptor::LWServerRequest::LWServerRequest (
    CORBA::Object_ptr obj,
    const char *op,
    CORBA::IOP::ServiceContextList &svc,
    CORBA::ServerRequest_ptr req)
    : Interceptor::LWRootRequest (_obj, _op, svc), _req (req),
      _obj (CORBA::Object::_duplicate (obj)), _op (op)
{
}

Interceptor::LWServerRequest::~LWServerRequest ()
{
}

const char *
Interceptor::LWServerRequest::_repoid() const
{
    return "IDL:omg.org/Interceptor/LWServerRequest:1.0";
}

Interceptor::LWServerRequest_ptr
Interceptor::LWServerRequest::_narrow (LWRootRequest_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/LWServerRequest:1.0"))
        return _duplicate ((LWServerRequest_ptr)_obj);
    return _nil();
}

CORBA::ServerRequest_ptr
Interceptor::LWServerRequest::request ()
{
    return CORBA::ServerRequest::_duplicate (_req);
}






namespace Interceptor {
  list<Interceptor::ClientInterceptor_ptr> *ClientInterceptor::_interceptors;
};





list<Interceptor::ClientInterceptor_ptr> &
Interceptor::ClientInterceptor::_ics ()
{
    if (!_interceptors)
        _interceptors = new list<Interceptor::ClientInterceptor_ptr>;
    return *_interceptors;
}

Interceptor::ClientInterceptor::ClientInterceptor ()
{
}

Interceptor::ClientInterceptor::ClientInterceptor (Priority p)
    : Interceptor::Root (p)
{
    insert_interceptor (_ics(), this);
}

Interceptor::ClientInterceptor::~ClientInterceptor ()
{
    remove_interceptor (_ics(), this);
}

const char *
Interceptor::ClientInterceptor::_repoid() const
{
    return "IDL:omg.org/Interceptor/ClientInterceptor:1.0";
}

Interceptor::ClientInterceptor_ptr
Interceptor::ClientInterceptor::_narrow (Root_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/ClientInterceptor:1.0"))
        return _duplicate ((ClientInterceptor_ptr)_obj);
    return _nil();
}

Interceptor::Status
Interceptor::ClientInterceptor::initialize_request (LWRequest_ptr req,
                                                    CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ClientInterceptor::after_marshal (LWRequest_ptr req,
                                               CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ClientInterceptor::output_message (CORBA::Buffer *buf,
                                                CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ClientInterceptor::input_message (CORBA::Buffer *buf,
                                               CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ClientInterceptor::before_unmarshal (LWRequest_ptr req,
                                                  CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ClientInterceptor::finish_request (LWRequest_ptr req,
                                                CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

void
Interceptor::ClientInterceptor::activate (Priority p)
{
    Root::activate (p);
    insert_interceptor (_ics(), this);
}

void
Interceptor::ClientInterceptor::deactivate ()
{
    Root::deactivate ();
    remove_interceptor (_ics(), this);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec (
    LWRequest_ptr req,
    CORBA::Environment_ptr env,
    InterceptorMethod1 m)
{
    if (_ics().size() == 0)
        return 1;

    ((void) ((!CORBA::is_nil (req)) ? 0 : (__assert_fail ("!CORBA::is_nil (req)", "intercept.cc", 464, __PRETTY_FUNCTION__), 0)));

    list<ClientInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = ((*i)->*m) (req, env);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 475, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env,
    InterceptorMethod2 m)
{
    if (_ics().size() == 0)
        return 1;

    list<ClientInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = ((*i)->*m) (buf, env);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 499, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_initialize_request (
    LWRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ClientInterceptor::initialize_request);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_after_marshal (
    LWRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ClientInterceptor::after_marshal);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_output_message (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env)
{
    return _exec (buf, env, &ClientInterceptor::output_message);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_input_message (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env)
{
    return _exec (buf, env, &ClientInterceptor::input_message);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_before_unmarshal (
    LWRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ClientInterceptor::before_unmarshal);
}

CORBA::Boolean
Interceptor::ClientInterceptor::_exec_finish_request (
    LWRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ClientInterceptor::finish_request);
}

Interceptor::LWRequest_ptr
Interceptor::ClientInterceptor::_create_request (
    CORBA::Object_var &obj,
    CORBA::String_var &op,
    CORBA::IOP::ServiceContextList &svc,
    CORBA::Request_ptr req)
{
    if (_ics().size() == 0)
        return LWRequest::_nil();
    return new LWRequest (obj, op, svc, req);
}






namespace Interceptor {
  list<Interceptor::ServerInterceptor_ptr> *ServerInterceptor::_interceptors;
};





list<Interceptor::ServerInterceptor_ptr> &
Interceptor::ServerInterceptor::_ics ()
{
    if (!_interceptors)
        _interceptors = new list<Interceptor::ServerInterceptor_ptr>;
    return *_interceptors;
}

Interceptor::ServerInterceptor::ServerInterceptor ()
{
}

Interceptor::ServerInterceptor::ServerInterceptor (Priority p)
    : Interceptor::Root (p)
{
    insert_interceptor (_ics(), this);
}

Interceptor::ServerInterceptor::~ServerInterceptor ()
{
    remove_interceptor (_ics(), this);
}

const char *
Interceptor::ServerInterceptor::_repoid() const
{
    return "IDL:omg.org/Interceptor/ServerInterceptor:1.0";
}

Interceptor::ServerInterceptor_ptr
Interceptor::ServerInterceptor::_narrow (Root_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/ServerInterceptor:1.0"))
        return _duplicate ((ServerInterceptor_ptr)_obj);
    return _nil();
}

Interceptor::Status
Interceptor::ServerInterceptor::input_message (CORBA::Buffer *buf,
                                               CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ServerInterceptor::initialize_request (LWServerRequest_ptr req,
                                                    CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ServerInterceptor::after_unmarshal (LWServerRequest_ptr req,
                                                 CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ServerInterceptor::before_marshal (LWServerRequest_ptr req,
                                                CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ServerInterceptor::finish_request (LWServerRequest_ptr req,
                                                CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ServerInterceptor::output_message (CORBA::Buffer *buf,
                                                CORBA::Environment_ptr env)
{
    return INVOKE_CONTINUE;
}

void
Interceptor::ServerInterceptor::activate (Priority p)
{
    Root::activate (p);
    insert_interceptor (_ics(), this);
}

void
Interceptor::ServerInterceptor::deactivate ()
{
    Root::deactivate ();
    remove_interceptor (_ics(), this);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec (
    LWServerRequest_ptr req,
    CORBA::Environment_ptr env,
    InterceptorMethod1 m)
{
    if (_ics().size() == 0)
        return 1;

    ((void) ((!CORBA::is_nil (req)) ? 0 : (__assert_fail ("!CORBA::is_nil (req)", "intercept.cc", 683, __PRETTY_FUNCTION__), 0)));

    list<ServerInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = ((*i)->*m) (req, env);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 694, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env,
    InterceptorMethod2 m)
{
    if (_ics().size() == 0)
        return 1;

    list<ServerInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = ((*i)->*m) (buf, env);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 718, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_input_message (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env)
{
    return _exec (buf, env, &ServerInterceptor::input_message);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_initialize_request (
    LWServerRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ServerInterceptor::initialize_request);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_after_unmarshal (
    LWServerRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ServerInterceptor::after_unmarshal);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_before_marshal (
    LWServerRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ServerInterceptor::before_marshal);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_finish_request (
    LWServerRequest_ptr req,
    CORBA::Environment_ptr env)
{
    return _exec (req, env, &ServerInterceptor::finish_request);
}

CORBA::Boolean
Interceptor::ServerInterceptor::_exec_output_message (
    CORBA::Buffer *buf,
    CORBA::Environment_ptr env)
{
    return _exec (buf, env, &ServerInterceptor::output_message);
}

Interceptor::LWServerRequest_ptr
Interceptor::ServerInterceptor::_create_request (
    CORBA::Object_ptr obj,
    const char *op,
    CORBA::IOP::ServiceContextList &svc,
    CORBA::ServerRequest_ptr req)
{
    if (_ics().size() == 0)
        return LWServerRequest::_nil();
    return new LWServerRequest (obj, op, svc, req);
}






namespace Interceptor {
  list<Interceptor::InitInterceptor_ptr> *InitInterceptor::_interceptors;
};





list<Interceptor::InitInterceptor_ptr> &
Interceptor::InitInterceptor::_ics ()
{
    if (!_interceptors)
        _interceptors = new list<Interceptor::InitInterceptor_ptr>;
    return *_interceptors;
}

Interceptor::InitInterceptor::InitInterceptor ()
{
}

Interceptor::InitInterceptor::InitInterceptor (Priority p)
    : Interceptor::Root (p)
{
    insert_interceptor (_ics(), this);
}

Interceptor::InitInterceptor::~InitInterceptor ()
{
    remove_interceptor (_ics(), this);
}

const char *
Interceptor::InitInterceptor::_repoid() const
{
    return "IDL:omg.org/Interceptor/InitInterceptor:1.0";
}

Interceptor::InitInterceptor_ptr
Interceptor::InitInterceptor::_narrow (Root_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/InitInterceptor:1.0"))
        return _duplicate ((InitInterceptor_ptr)_obj);
    return _nil();
}

Interceptor::Status
Interceptor::InitInterceptor::initialize (CORBA::ORB_ptr orb,
                                          const char *id,
                                          int &argc, char *argv[])
{
    return INVOKE_CONTINUE;
}

void
Interceptor::InitInterceptor::activate (Priority p)
{
    Root::activate (p);
    insert_interceptor (_ics(), this);
}

void
Interceptor::InitInterceptor::deactivate ()
{
    Root::deactivate ();
    remove_interceptor (_ics(), this);
}

CORBA::Boolean
Interceptor::InitInterceptor::_exec_initialize (CORBA::ORB_ptr orb,
                                                const char *id,
                                                int &argc, char *argv[])
{
    if (_ics().size() == 0)
        return 1;

    list<InitInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->initialize (orb, id, argc, argv);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 876, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}






namespace Interceptor {
  list<Interceptor::BOAInterceptor_ptr> *BOAInterceptor::_interceptors;
};





list<Interceptor::BOAInterceptor_ptr> &
Interceptor::BOAInterceptor::_ics ()
{
    if (!_interceptors)
        _interceptors = new list<Interceptor::BOAInterceptor_ptr>;
    return *_interceptors;
}

Interceptor::BOAInterceptor::BOAInterceptor ()
{
}

Interceptor::BOAInterceptor::BOAInterceptor (Priority p)
    : Interceptor::Root (p)
{
    insert_interceptor (_ics(), this);
}

Interceptor::BOAInterceptor::~BOAInterceptor ()
{
    remove_interceptor (_ics(), this);
}

const char *
Interceptor::BOAInterceptor::_repoid() const
{
    return "IDL:omg.org/Interceptor/BOAInterceptor:1.0";
}

Interceptor::BOAInterceptor_ptr
Interceptor::BOAInterceptor::_narrow (Root_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/BOAInterceptor:1.0"))
        return _duplicate ((BOAInterceptor_ptr)_obj);
    return _nil();
}

Interceptor::Status
Interceptor::BOAInterceptor::bind (const char *repoid,
                                   const CORBA::ORB::ObjectTag &)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::BOAInterceptor::restore (CORBA::Object_ptr obj)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::BOAInterceptor::create (CORBA::Object_ptr obj)
{
    return INVOKE_CONTINUE;
}

void
Interceptor::BOAInterceptor::activate (Priority p)
{
    Root::activate (p);
    insert_interceptor (_ics(), this);
}

void
Interceptor::BOAInterceptor::deactivate ()
{
    Root::deactivate ();
    remove_interceptor (_ics(), this);
}

CORBA::Boolean
Interceptor::BOAInterceptor::_exec_bind (const char *repoid,
                                         const CORBA::ORB::ObjectTag &tag)
{
    if (_ics().size() == 0)
        return 1;

    list<BOAInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->bind (repoid, tag);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 984, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::BOAInterceptor::_exec_restore (CORBA::Object_ptr obj)
{
    if (_ics().size() == 0)
        return 1;

    list<BOAInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->restore (obj);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 1005, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::BOAInterceptor::_exec_create (CORBA::Object_ptr obj)
{
    if (_ics().size() == 0)
        return 1;

    list<BOAInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->create (obj);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 1026, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}






namespace Interceptor {
  list<Interceptor::ConnInterceptor_ptr> *ConnInterceptor::_interceptors;
};





list<Interceptor::ConnInterceptor_ptr> &
Interceptor::ConnInterceptor::_ics ()
{
    if (!_interceptors)
        _interceptors = new list<Interceptor::ConnInterceptor_ptr>;
    return *_interceptors;
}

Interceptor::ConnInterceptor::ConnInterceptor ()
{
}

Interceptor::ConnInterceptor::ConnInterceptor (Priority p)
    : Interceptor::Root (p)
{
    insert_interceptor (_ics(), this);
}

Interceptor::ConnInterceptor::~ConnInterceptor ()
{
    remove_interceptor (_ics(), this);
}

const char *
Interceptor::ConnInterceptor::_repoid() const
{
    return "IDL:omg.org/Interceptor/ConnInterceptor:1.0";
}

Interceptor::ConnInterceptor_ptr
Interceptor::ConnInterceptor::_narrow (Root_ptr _obj)
{
    if (CORBA::is_nil (_obj))
        return _nil();
    if (!strcmp (_obj->_repoid(),
                 "IDL:omg.org/Interceptor/ConnInterceptor:1.0"))
        return _duplicate ((ConnInterceptor_ptr)_obj);
    return _nil();
}

Interceptor::Status
Interceptor::ConnInterceptor::client_connect (const char *addr)
{
    return INVOKE_CONTINUE;
}

Interceptor::Status
Interceptor::ConnInterceptor::client_disconnect (const char *addr)
{
    return INVOKE_CONTINUE;
}

void
Interceptor::ConnInterceptor::activate (Priority p)
{
    Root::activate (p);
    insert_interceptor (_ics(), this);
}

void
Interceptor::ConnInterceptor::deactivate ()
{
    Root::deactivate ();
    remove_interceptor (_ics(), this);
}

CORBA::Boolean
Interceptor::ConnInterceptor::_exec_client_connect (const char *addr)
{
    if (_ics().size() == 0)
        return 1;

    list<ConnInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->client_connect (addr);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 1126, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}

CORBA::Boolean
Interceptor::ConnInterceptor::_exec_client_disconnect (const char *addr)
{
    if (_ics().size() == 0)
        return 1;

    list<ConnInterceptor_ptr>::iterator i;
    for (i = _ics().begin(); i != _ics().end(); ++i) {
        Status s = (*i)->client_disconnect (addr);
        if (s == INVOKE_ABORT)
            return 0;
        if (s == INVOKE_BREAK)
            return 1;
        if (s == INVOKE_RETRY) {

            ((void) ((0) ? 0 : (__assert_fail ("0", "intercept.cc", 1147, __PRETTY_FUNCTION__), 0)));
        }
    }
    return 1;
}
# 28 "orb_all.cc" 2
# 1 "os-unix.cc" 1
# 25 "os-unix.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 26 "os-unix.cc" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 27 "os-unix.cc" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 28 "os-unix.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 29 "os-unix.cc" 2
# 1 "/usr/include/errno.h" 1 3 4
# 30 "os-unix.cc" 2

# 1 "/usr/include/dlfcn.h" 1 3 4
# 23 "/usr/include/dlfcn.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 24 "/usr/include/dlfcn.h" 2 3 4


# 1 "/usr/include/bits/dlfcn.h" 1 3 4
# 27 "/usr/include/dlfcn.h" 2 3 4
# 39 "/usr/include/dlfcn.h" 3 4
extern "C" {



extern void *dlopen (__const char *__file, int __mode) throw ();



extern int dlclose (void *__handle) throw ();



extern void *dlsym (void *__restrict __handle, __const char *__restrict __name) throw ();





extern void *dlvsym (void *__restrict __handle, __const char *__restrict __name, __const char *__restrict __version) throw ();







extern char *dlerror (void) throw ();




typedef struct
  {
    __const char *dli_fname;
    void *dli_fbase;
    __const char *dli_sname;
    void *dli_saddr;
  } Dl_info;
extern int dladdr (const void *__address, Dl_info *__info) throw ();
# 93 "/usr/include/dlfcn.h" 3 4
extern void _dl_mcount_wrapper_check (void *__selfpc) throw ();


}
# 32 "os-unix.cc" 2




# 1 "/usr/include/signal.h" 1 3 4
# 37 "os-unix.cc" 2
# 1 "/usr/include/unistd.h" 1 3 4
# 38 "os-unix.cc" 2
# 1 "/usr/include/sys/types.h" 1 3 4
# 39 "os-unix.cc" 2
# 1 "/usr/include/sys/wait.h" 1 3 4
# 26 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 27 "/usr/include/sys/wait.h" 2 3 4

extern "C" {

# 1 "/usr/include/bits/types.h" 1 3 4
# 31 "/usr/include/sys/wait.h" 2 3 4
# 39 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 40 "/usr/include/sys/wait.h" 2 3 4
# 81 "/usr/include/sys/wait.h" 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 63 "/usr/include/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 64 "/usr/include/bits/waitstatus.h" 2 3 4

union wait
  {
    int w_status;
    struct
      {

        unsigned int __w_termsig:7;
        unsigned int __w_coredump:1;
        unsigned int __w_retcode:8;
        unsigned int:16;







      } __wait_terminated;
    struct
      {

        unsigned int __w_stopval:8;
        unsigned int __w_stopsig:8;
        unsigned int:16;






      } __wait_stopped;
  };
# 82 "/usr/include/sys/wait.h" 2 3 4
# 99 "/usr/include/sys/wait.h" 3 4
typedef enum
{
  P_ALL,
  P_PID,
  P_PGID
} idtype_t;





extern __pid_t __wait (void * __stat_loc) throw ();
extern __pid_t wait (void * __stat_loc) throw ();
# 131 "/usr/include/sys/wait.h" 3 4
extern __pid_t waitpid (__pid_t __pid, int *__stat_loc, int __options) throw ();




# 1 "/usr/include/bits/siginfo.h" 1 3 4
# 137 "/usr/include/sys/wait.h" 2 3 4
# 145 "/usr/include/sys/wait.h" 3 4
extern int waitid (idtype_t __idtype, __id_t __id, siginfo_t *__infop, int __options) throw ();






struct rusage;






extern __pid_t wait3 (void * __stat_loc, int __options, struct rusage * __usage) throw ();






struct rusage;


extern __pid_t wait4 (__pid_t __pid, void * __stat_loc, int __options, struct rusage *__usage) throw ();




}
# 40 "os-unix.cc" 2

# 1 "/opt/gcc3/include/g++-v3/algorithm" 1 3
# 42 "os-unix.cc" 2
# 1 "../include/mico/impl.h" 1
# 43 "os-unix.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 44 "os-unix.cc" 2
# 1 "../include/mico/util.h" 1
# 45 "os-unix.cc" 2
# 1 "../include/mico/os-math.h" 1
# 46 "os-unix.cc" 2





MICO_Double OSMath::_infinity = 0;
MICO_LongDouble OSMath::_long_infinity = 0;
MICO_Double OSMath::_notanumber = 0;
MICO_LongDouble OSMath::_long_notanumber = 0;






namespace MICO {
  MICO::UnixProcess::ListProcess UnixProcess::_procs;
};




void
MICO::UnixProcess::signal_handler (int sig)
{
    int status;
    while (42) {
        CORBA::Long pid = ::waitpid (-1, &status, 1);
        if (pid < 0 && (*__errno_location ()) == 4)
            continue;
        if (pid <= 0)
            break;

        ListProcess::iterator i;
        for (i = _procs.begin(); i != _procs.end(); ++i) {
            if (pid == (*i)->_pid) {
                if (((((*(int *) &((status)))) & 0x7f) == 0)) {
                    (*i)->_exit_status = ((((*(int *) &((status)))) & 0xff00) >> 8);
                } else {
                    (*i)->_exit_status = 1000;
                }
                if ((*i)->_cb) {
                    CORBA::ORB_ptr orb = CORBA::ORB_instance("mico-local-orb");
                    CORBA::Dispatcher *disp = orb->dispatcher();
                    disp->remove (*i, CORBA::Dispatcher::Timer);
                    disp->tm_event (*i, 0);
                }
                break;
            }
        }
    }
    ::signal (17, signal_handler);
}

MICO::UnixProcess::UnixProcess (const char *cmd, MICO::ProcessCallback *cb)
{
    _exit_status = -1;
    _pid = 0;
    _detached = 0;
    _cb = cb;
    _procs.push_back (this);
    _args = cmd;
}

MICO::UnixProcess::~UnixProcess ()
{
    ListProcess::iterator pos = find (_procs.begin(), _procs.end(), this);
    ((void) ((pos != _procs.end()) ? 0 : (__assert_fail ("pos != _procs.end()", "os-unix.cc", 113, __PRETTY_FUNCTION__), 0)));
    _procs.erase (pos);

    if (!_detached && !exited())
        terminate ();
}

CORBA::Boolean
MICO::UnixProcess::run ()
{
    ::signal (17, signal_handler);

    _pid = ::fork ();
    if (_pid == 0) {
        string command;


        command = "exec ";

        command += _args;
        ::execl ("/bin/sh", "/bin/sh", "-c", command.c_str(), __null);
        exit (1);
    }
    return _pid > 0;
}

CORBA::Boolean
MICO::UnixProcess::exited ()
{
    return _pid <= 0 || _exit_status >= 0;
}

CORBA::Boolean
MICO::UnixProcess::exit_status ()
{
    return _exit_status == 0;
}

void
MICO::UnixProcess::terminate ()
{
    ((void) ((_pid > 0) ? 0 : (__assert_fail ("_pid > 0", "os-unix.cc", 154, __PRETTY_FUNCTION__), 0)));
    ::kill (_pid, 15);
}

void
MICO::UnixProcess::detach ()
{
    _detached = 1;
    _cb = 0;
}

MICO::UnixProcess::operator CORBA::Boolean ()
{
    return _pid > 0;
}

void
MICO::UnixProcess::callback (CORBA::Dispatcher *disp,
                             CORBA::DispatcherCallback::Event ev)
{
    if (ev == CORBA::Dispatcher::Timer && _cb)
        _cb->callback (this, MICO::ProcessCallback::Exited);
}
# 282 "os-unix.cc"
MICO::UnixSharedLib::UnixSharedLib (const char *name)
{
    _name = name;
    _handle = 0;
}

MICO::UnixSharedLib::~UnixSharedLib ()
{
}

void *
MICO::UnixSharedLib::symbol (const char *sym)
{
    return 0;
}

const char *
MICO::UnixSharedLib::error ()
{
    return "no shlib support";
}

MICO::UnixSharedLib::operator CORBA::Boolean ()
{
    return 0;
}

const char *
MICO::UnixSharedLib::name ()
{
    return _name.c_str();
}
# 29 "orb_all.cc" 2
# 1 "ssl.cc" 1
# 25 "ssl.cc"
# 1 "/usr/include/stdlib.h" 1 3 4
# 26 "ssl.cc" 2
# 1 "/usr/include/string.h" 1 3 4
# 27 "ssl.cc" 2
# 1 "../include/CORBA-SMALL.h" 1
# 28 "ssl.cc" 2
# 1 "../include/mico/util.h" 1
# 29 "ssl.cc" 2
# 1 "../include/mico/impl.h" 1
# 30 "ssl.cc" 2
# 1 "../include/mico/intercept.h" 1
# 31 "ssl.cc" 2
# 1 "../include/mico/ssl.h" 1
# 32 "ssl.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 33 "ssl.cc" 2
# 30 "orb_all.cc" 2
# 1 "current.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "current.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "current.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "current.cc" 2






CORBA::Current::~Current()
{
}

void *CORBA::Current::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/CORBA/Current:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

CORBA::Current_ptr CORBA::Current::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/CORBA/Current:1.0" )))
      return _duplicate( (CORBA::Current_ptr) _p );
  }
  return _nil();
}

CORBA::Current_ptr
CORBA::Current::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}




CORBA::PrincipalCurrent::~PrincipalCurrent()
{
}

void *CORBA::PrincipalCurrent::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/CORBA/PrincipalCurrent:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Current _VCHACK__CORBA__Current;
    if ((_p = _VCHACK__CORBA__Current::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

CORBA::PrincipalCurrent_ptr CORBA::PrincipalCurrent::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/CORBA/PrincipalCurrent:1.0" )))
      return _duplicate( (CORBA::PrincipalCurrent_ptr) _p );
  }
  return _nil();
}

CORBA::PrincipalCurrent_ptr
CORBA::PrincipalCurrent::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}


struct __tc_init_CURRENT {
  __tc_init_CURRENT()
  {
  }
};

static __tc_init_CURRENT __init_CURRENT;
# 31 "orb_all.cc" 2
# 1 "valuetype.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "valuetype.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "valuetype.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "valuetype.cc" 2






CORBA::StringValue::StringValue ()
{
}

CORBA::StringValue::StringValue (char * _p)
{
  value = _p;
}

CORBA::StringValue::StringValue (const char * _p)
{
  value = _p;
}

CORBA::StringValue::StringValue (const CORBA::String_var & _p)
{
  value = _p;
}

CORBA::StringValue::StringValue (const StringValue& _p)
{
  value = _p.value;
}

CORBA::StringValue::~StringValue ()
{
}

CORBA::StringValue &
CORBA::StringValue::operator= (char * _p)
{
  value = _p;
  return *this;
}

CORBA::StringValue &
CORBA::StringValue::operator= (const char * _p)
{
  value = _p;
  return *this;
}

CORBA::StringValue &
CORBA::StringValue::operator= (const CORBA::String_var & _p)
{
  value = _p;
  return *this;
}

const char *
CORBA::StringValue::_value () const
{
  return value;
}

void
CORBA::StringValue::_value (char * _p)
{
  value = _p;
}

void
CORBA::StringValue::_value (const char * _p)
{
  value = _p;
}

void
CORBA::StringValue::_value (const CORBA::String_var & _p)
{
  value = _p;
}

char &
CORBA::StringValue::operator[] (CORBA::ULong idx)
{
  return value[idx];
}

char
CORBA::StringValue::operator[] (CORBA::ULong idx) const
{
  return value[idx];
}

const char*
CORBA::StringValue::_boxed_in() const
{
  return value.in();
}

char*&
CORBA::StringValue::_boxed_inout()
{
  return value.inout();
}

char*&
CORBA::StringValue::_boxed_out()
{
  return value.out();
}

void *
CORBA::StringValue::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/CORBA/StringValue:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

CORBA::StringValue *
CORBA::StringValue::_downcast (CORBA::ValueBase *vb)
{
  void * p;
  if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/CORBA/StringValue:1.0")))) {
    return (CORBA::StringValue *) p;
  }
  return 0;
}

CORBA::StringValue *
CORBA::StringValue::_downcast (CORBA::AbstractBase *)
{
  return 0;
}

CORBA::ValueDef_ptr
CORBA::StringValue::get_value_def ()
{
  return CORBA::ValueDef::_nil ();
}

CORBA::ValueBase *
CORBA::StringValue::_copy_value ()
{
  return new StringValue (*this);
}

void
CORBA::StringValue::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
{
  repoids.push_back ("IDL:omg.org/CORBA/StringValue:1.0");
  chunked = 0;
}

void
CORBA::StringValue::_marshal_members (CORBA::DataEncoder &ec)
{
  CORBA::_stc_string->marshal (ec, &value.inout());
}

CORBA::Boolean
CORBA::StringValue::_demarshal_members (CORBA::DataDecoder &ec)
{
  return CORBA::_stc_string->demarshal (ec, &value._for_demarshal());
}

class _Marshaller_CORBA_StringValue : public CORBA::StaticTypeInfo {
    typedef CORBA::StringValue* _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_CORBA_StringValue::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_CORBA_StringValue::assign( StaticValueType d, const StaticValueType s ) const
{
  CORBA::remove_ref (*(_MICO_T*)d);
  CORBA::add_ref (*(_MICO_T*)s);
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_CORBA_StringValue::free( StaticValueType v ) const
{
  CORBA::remove_ref (*(_MICO_T*)v);
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_CORBA_StringValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ValueBase* vb;
  if (!CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/CORBA/StringValue:1.0")) {
    return 0;
  }
  *(_MICO_T *)v = ::CORBA::StringValue::_downcast (vb);
  if (vb && !*(_MICO_T *)v) {
    CORBA::remove_ref (vb);
    return 0;
  }
  return 1;
}

void _Marshaller_CORBA_StringValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
}

CORBA::TypeCode_ptr _Marshaller_CORBA_StringValue::typecode()
{
  return CORBA::_tc_StringValue;
}

CORBA::StaticTypeInfo *_marshaller_CORBA_StringValue;


namespace CORBA { CORBA::TypeCodeConst _tc_StringValue; };




void
operator<<=( CORBA::Any &_a, const CORBA::StringValue* _val )
{
  CORBA::StaticAny _sa (_marshaller_CORBA_StringValue, &_val);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, CORBA::StringValue** _val_ptr )
{
  CORBA::ValueBase_var _val = *_val_ptr;
  CORBA::StaticAny _sa (_marshaller_CORBA_StringValue, _val_ptr);
  _a.from_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, CORBA::StringValue* &_val_ptr )
{
  CORBA::StringValue* *p;
  if (_a.to_static_any (_marshaller_CORBA_StringValue, (void *&)p)) {
    _val_ptr = *p;
    return 1;
  }
  return 0;
}



CORBA::WStringValue::WStringValue ()
{
}

CORBA::WStringValue::WStringValue (CORBA::WChar * _p)
{
  value = _p;
}

CORBA::WStringValue::WStringValue (const CORBA::WChar * _p)
{
  value = _p;
}

CORBA::WStringValue::WStringValue (const CORBA::WString_var & _p)
{
  value = _p;
}

CORBA::WStringValue::WStringValue (const WStringValue& _p)
{
  value = _p.value;
}

CORBA::WStringValue::~WStringValue ()
{
}

CORBA::WStringValue &
CORBA::WStringValue::operator= (CORBA::WChar * _p)
{
  value = _p;
  return *this;
}

CORBA::WStringValue &
CORBA::WStringValue::operator= (const CORBA::WChar * _p)
{
  value = _p;
  return *this;
}

CORBA::WStringValue &
CORBA::WStringValue::operator= (const CORBA::WString_var & _p)
{
  value = _p;
  return *this;
}

const CORBA::WChar *
CORBA::WStringValue::_value () const
{
  return value;
}

void
CORBA::WStringValue::_value (CORBA::WChar * _p)
{
  value = _p;
}

void
CORBA::WStringValue::_value (const CORBA::WChar * _p)
{
  value = _p;
}

void
CORBA::WStringValue::_value (const CORBA::WString_var & _p)
{
  value = _p;
}

CORBA::WChar &
CORBA::WStringValue::operator[] (CORBA::ULong idx)
{
  return value[idx];
}

CORBA::WChar
CORBA::WStringValue::operator[] (CORBA::ULong idx) const
{
  return value[idx];
}

const CORBA::WChar*
CORBA::WStringValue::_boxed_in() const
{
  return value.in();
}

CORBA::WChar*&
CORBA::WStringValue::_boxed_inout()
{
  return value.inout();
}

CORBA::WChar*&
CORBA::WStringValue::_boxed_out()
{
  return value.out();
}

void *
CORBA::WStringValue::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/CORBA/WStringValue:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

CORBA::WStringValue *
CORBA::WStringValue::_downcast (CORBA::ValueBase *vb)
{
  void * p;
  if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/CORBA/WStringValue:1.0")))) {
    return (CORBA::WStringValue *) p;
  }
  return 0;
}

CORBA::WStringValue *
CORBA::WStringValue::_downcast (CORBA::AbstractBase *)
{
  return 0;
}

CORBA::ValueDef_ptr
CORBA::WStringValue::get_value_def ()
{
  return CORBA::ValueDef::_nil ();
}

CORBA::ValueBase *
CORBA::WStringValue::_copy_value ()
{
  return new WStringValue (*this);
}

void
CORBA::WStringValue::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
{
  repoids.push_back ("IDL:omg.org/CORBA/WStringValue:1.0");
  chunked = 0;
}

void
CORBA::WStringValue::_marshal_members (CORBA::DataEncoder &ec)
{
  CORBA::_stc_wstring->marshal (ec, &value.inout());
}

CORBA::Boolean
CORBA::WStringValue::_demarshal_members (CORBA::DataDecoder &ec)
{
  return CORBA::_stc_wstring->demarshal (ec, &value._for_demarshal());
}

class _Marshaller_CORBA_WStringValue : public CORBA::StaticTypeInfo {
    typedef CORBA::WStringValue* _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_CORBA_WStringValue::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_CORBA_WStringValue::assign( StaticValueType d, const StaticValueType s ) const
{
  CORBA::remove_ref (*(_MICO_T*)d);
  CORBA::add_ref (*(_MICO_T*)s);
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_CORBA_WStringValue::free( StaticValueType v ) const
{
  CORBA::remove_ref (*(_MICO_T*)v);
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_CORBA_WStringValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ValueBase* vb;
  if (!CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/CORBA/WStringValue:1.0")) {
    return 0;
  }
  *(_MICO_T *)v = ::CORBA::WStringValue::_downcast (vb);
  if (vb && !*(_MICO_T *)v) {
    CORBA::remove_ref (vb);
    return 0;
  }
  return 1;
}

void _Marshaller_CORBA_WStringValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
}

CORBA::TypeCode_ptr _Marshaller_CORBA_WStringValue::typecode()
{
  return CORBA::_tc_WStringValue;
}

CORBA::StaticTypeInfo *_marshaller_CORBA_WStringValue;


namespace CORBA { CORBA::TypeCodeConst _tc_WStringValue; };




void
operator<<=( CORBA::Any &_a, const CORBA::WStringValue* _val )
{
  CORBA::StaticAny _sa (_marshaller_CORBA_WStringValue, &_val);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, CORBA::WStringValue** _val_ptr )
{
  CORBA::ValueBase_var _val = *_val_ptr;
  CORBA::StaticAny _sa (_marshaller_CORBA_WStringValue, _val_ptr);
  _a.from_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, CORBA::WStringValue* &_val_ptr )
{
  CORBA::WStringValue* *p;
  if (_a.to_static_any (_marshaller_CORBA_WStringValue, (void *&)p)) {
    _val_ptr = *p;
    return 1;
  }
  return 0;
}



CORBA::CustomMarshal::CustomMarshal ()
{
}

CORBA::CustomMarshal::~CustomMarshal ()
{
}

void *
CORBA::CustomMarshal::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/CORBA/CustomMarshal:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

CORBA::CustomMarshal *
CORBA::CustomMarshal::_downcast (CORBA::ValueBase * vb)
{
  void * p;
  if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/CORBA/CustomMarshal:1.0")))) {
    return (CORBA::CustomMarshal *) p;
  }
  return 0;
}

CORBA::CustomMarshal *
CORBA::CustomMarshal::_downcast (CORBA::AbstractBase * vb)
{
  return _downcast (vb->_to_value());
}

CORBA::ValueDef_ptr
CORBA::CustomMarshal::get_value_def ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  ((void) ((!CORBA::is_nil (ifr)) ? 0 : (__assert_fail ("!CORBA::is_nil (ifr)", "valuetype.cc", 555, __PRETTY_FUNCTION__), 0)));

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/CORBA/CustomMarshal:1.0");
  CORBA::ValueDef_ptr val = CORBA::ValueDef::_narrow (cv);
  return val;
}

void
CORBA::CustomMarshal::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
{
  repoids.push_back ("IDL:omg.org/CORBA/CustomMarshal:1.0");
  chunked = 0;
}

void
CORBA::CustomMarshal::_marshal_members (CORBA::DataEncoder &ec)
{
}

CORBA::Boolean
CORBA::CustomMarshal::_demarshal_members (CORBA::DataDecoder &dc)
{
  return 1;
}

class _Marshaller_CORBA_CustomMarshal : public CORBA::StaticTypeInfo {
    typedef CORBA::CustomMarshal* _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_CORBA_CustomMarshal::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_CORBA_CustomMarshal::assign( StaticValueType d, const StaticValueType s ) const
{
  CORBA::remove_ref (*(_MICO_T*)d);
  CORBA::add_ref (*(_MICO_T*)s);
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_CORBA_CustomMarshal::free( StaticValueType v ) const
{
  CORBA::remove_ref (*(_MICO_T*)v);
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_CORBA_CustomMarshal::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ValueBase* vb;
  if (!CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/CORBA/CustomMarshal:1.0")) {
    return 0;
  }
  *(_MICO_T *)v = ::CORBA::CustomMarshal::_downcast (vb);
  if (vb && !*(_MICO_T *)v) {
    CORBA::remove_ref (vb);
    return 0;
  }
  return 1;
}

void _Marshaller_CORBA_CustomMarshal::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
}

CORBA::TypeCode_ptr _Marshaller_CORBA_CustomMarshal::typecode()
{
  return CORBA::_tc_CustomMarshal;
}

CORBA::StaticTypeInfo *_marshaller_CORBA_CustomMarshal;


namespace CORBA { CORBA::TypeCodeConst _tc_CustomMarshal; };




void
operator<<=( CORBA::Any &_a, const CORBA::CustomMarshal* _val )
{
  CORBA::StaticAny _sa (_marshaller_CORBA_CustomMarshal, &_val);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, CORBA::CustomMarshal** _val_ptr )
{
  CORBA::ValueBase_var _val = *_val_ptr;
  CORBA::StaticAny _sa (_marshaller_CORBA_CustomMarshal, _val_ptr);
  _a.from_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, CORBA::CustomMarshal* &_val_ptr )
{
  CORBA::CustomMarshal* *p;
  if (_a.to_static_any (_marshaller_CORBA_CustomMarshal, (void *&)p)) {
    _val_ptr = *p;
    return 1;
  }
  return 0;
}



CORBA::DataOutputStream::DataOutputStream ()
{
}

CORBA::DataOutputStream::~DataOutputStream ()
{
}

void *
CORBA::DataOutputStream::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/CORBA/DataOutputStream:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

CORBA::DataOutputStream *
CORBA::DataOutputStream::_downcast (CORBA::ValueBase * vb)
{
  void * p;
  if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/CORBA/DataOutputStream:1.0")))) {
    return (CORBA::DataOutputStream *) p;
  }
  return 0;
}

CORBA::DataOutputStream *
CORBA::DataOutputStream::_downcast (CORBA::AbstractBase * vb)
{
  return _downcast (vb->_to_value());
}

CORBA::ValueDef_ptr
CORBA::DataOutputStream::get_value_def ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  ((void) ((!CORBA::is_nil (ifr)) ? 0 : (__assert_fail ("!CORBA::is_nil (ifr)", "valuetype.cc", 710, __PRETTY_FUNCTION__), 0)));

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/CORBA/DataOutputStream:1.0");
  CORBA::ValueDef_ptr val = CORBA::ValueDef::_narrow (cv);
  return val;
}

void
CORBA::DataOutputStream::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
{
  repoids.push_back ("IDL:omg.org/CORBA/DataOutputStream:1.0");
  chunked = 0;
}

void
CORBA::DataOutputStream::_marshal_members (CORBA::DataEncoder &ec)
{
}

CORBA::Boolean
CORBA::DataOutputStream::_demarshal_members (CORBA::DataDecoder &dc)
{
  return 1;
}

class _Marshaller_CORBA_DataOutputStream : public CORBA::StaticTypeInfo {
    typedef CORBA::DataOutputStream* _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_CORBA_DataOutputStream::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_CORBA_DataOutputStream::assign( StaticValueType d, const StaticValueType s ) const
{
  CORBA::remove_ref (*(_MICO_T*)d);
  CORBA::add_ref (*(_MICO_T*)s);
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_CORBA_DataOutputStream::free( StaticValueType v ) const
{
  CORBA::remove_ref (*(_MICO_T*)v);
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_CORBA_DataOutputStream::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ValueBase* vb;
  if (!CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/CORBA/DataOutputStream:1.0")) {
    return 0;
  }
  *(_MICO_T *)v = ::CORBA::DataOutputStream::_downcast (vb);
  if (vb && !*(_MICO_T *)v) {
    CORBA::remove_ref (vb);
    return 0;
  }
  return 1;
}

void _Marshaller_CORBA_DataOutputStream::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
}

CORBA::TypeCode_ptr _Marshaller_CORBA_DataOutputStream::typecode()
{
  return CORBA::_tc_DataOutputStream;
}

CORBA::StaticTypeInfo *_marshaller_CORBA_DataOutputStream;


namespace CORBA { CORBA::TypeCodeConst _tc_DataOutputStream; };




void
operator<<=( CORBA::Any &_a, const CORBA::DataOutputStream* _val )
{
  CORBA::StaticAny _sa (_marshaller_CORBA_DataOutputStream, &_val);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, CORBA::DataOutputStream** _val_ptr )
{
  CORBA::ValueBase_var _val = *_val_ptr;
  CORBA::StaticAny _sa (_marshaller_CORBA_DataOutputStream, _val_ptr);
  _a.from_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, CORBA::DataOutputStream* &_val_ptr )
{
  CORBA::DataOutputStream* *p;
  if (_a.to_static_any (_marshaller_CORBA_DataOutputStream, (void *&)p)) {
    _val_ptr = *p;
    return 1;
  }
  return 0;
}



CORBA::DataInputStream::DataInputStream ()
{
}

CORBA::DataInputStream::~DataInputStream ()
{
}

void *
CORBA::DataInputStream::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/CORBA/DataInputStream:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

CORBA::DataInputStream *
CORBA::DataInputStream::_downcast (CORBA::ValueBase * vb)
{
  void * p;
  if (vb && ((p = vb->_narrow_helper ("IDL:omg.org/CORBA/DataInputStream:1.0")))) {
    return (CORBA::DataInputStream *) p;
  }
  return 0;
}

CORBA::DataInputStream *
CORBA::DataInputStream::_downcast (CORBA::AbstractBase * vb)
{
  return _downcast (vb->_to_value());
}

CORBA::ValueDef_ptr
CORBA::DataInputStream::get_value_def ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  ((void) ((!CORBA::is_nil (ifr)) ? 0 : (__assert_fail ("!CORBA::is_nil (ifr)", "valuetype.cc", 865, __PRETTY_FUNCTION__), 0)));

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/CORBA/DataInputStream:1.0");
  CORBA::ValueDef_ptr val = CORBA::ValueDef::_narrow (cv);
  return val;
}

void
CORBA::DataInputStream::_get_marshal_info (vector<string> & repoids, CORBA::Boolean & chunked)
{
  repoids.push_back ("IDL:omg.org/CORBA/DataInputStream:1.0");
  chunked = 0;
}

void
CORBA::DataInputStream::_marshal_members (CORBA::DataEncoder &ec)
{
}

CORBA::Boolean
CORBA::DataInputStream::_demarshal_members (CORBA::DataDecoder &dc)
{
  return 1;
}

class _Marshaller_CORBA_DataInputStream : public CORBA::StaticTypeInfo {
    typedef CORBA::DataInputStream* _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_CORBA_DataInputStream::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_CORBA_DataInputStream::assign( StaticValueType d, const StaticValueType s ) const
{
  CORBA::remove_ref (*(_MICO_T*)d);
  CORBA::add_ref (*(_MICO_T*)s);
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_CORBA_DataInputStream::free( StaticValueType v ) const
{
  CORBA::remove_ref (*(_MICO_T*)v);
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_CORBA_DataInputStream::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ValueBase* vb;
  if (!CORBA::ValueBase::_demarshal (dc, vb, "IDL:omg.org/CORBA/DataInputStream:1.0")) {
    return 0;
  }
  *(_MICO_T *)v = ::CORBA::DataInputStream::_downcast (vb);
  if (vb && !*(_MICO_T *)v) {
    CORBA::remove_ref (vb);
    return 0;
  }
  return 1;
}

void _Marshaller_CORBA_DataInputStream::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ValueBase::_marshal (ec, *(_MICO_T *)v);
}

CORBA::TypeCode_ptr _Marshaller_CORBA_DataInputStream::typecode()
{
  return CORBA::_tc_DataInputStream;
}

CORBA::StaticTypeInfo *_marshaller_CORBA_DataInputStream;


namespace CORBA { CORBA::TypeCodeConst _tc_DataInputStream; };




void
operator<<=( CORBA::Any &_a, const CORBA::DataInputStream* _val )
{
  CORBA::StaticAny _sa (_marshaller_CORBA_DataInputStream, &_val);
  _a.from_static_any (_sa);
}

void
operator<<=( CORBA::Any &_a, CORBA::DataInputStream** _val_ptr )
{
  CORBA::ValueBase_var _val = *_val_ptr;
  CORBA::StaticAny _sa (_marshaller_CORBA_DataInputStream, _val_ptr);
  _a.from_static_any (_sa);
}

CORBA::Boolean
operator>>=( const CORBA::Any &_a, CORBA::DataInputStream* &_val_ptr )
{
  CORBA::DataInputStream* *p;
  if (_a.to_static_any (_marshaller_CORBA_DataInputStream, (void *&)p)) {
    _val_ptr = *p;
    return 1;
  }
  return 0;
}

struct __tc_init_VALUETYPE {
  __tc_init_VALUETYPE()
  {
    _marshaller_CORBA_StringValue = new _Marshaller_CORBA_StringValue;
    CORBA::_tc_StringValue =
    "000000000000001e00000044000000000000002249444c3a6f6d672e6f72"
    "672f434f5242412f537472696e6756616c75653a312e300000000000000c"
    "537472696e6756616c7565000000001200000000";
    _marshaller_CORBA_WStringValue = new _Marshaller_CORBA_WStringValue;
    CORBA::_tc_WStringValue =
    "000000000000001e00000048000000000000002349444c3a6f6d672e6f72"
    "672f434f5242412f57537472696e6756616c75653a312e3000000000000d"
    "57537472696e6756616c7565000000000000001b00000000";
    _marshaller_CORBA_CustomMarshal = new _Marshaller_CORBA_CustomMarshal;
    CORBA::_tc_CustomMarshal =
    "000000000000001d00000048000000000000002449444c3a6f6d672e6f72"
    "672f434f5242412f437573746f6d4d61727368616c3a312e30000000000e"
    "437573746f6d4d61727368616c0000020000000000000000";
    _marshaller_CORBA_DataOutputStream = new _Marshaller_CORBA_DataOutputStream;
    CORBA::_tc_DataOutputStream =
    "000000000000001d00000050000000000000002749444c3a6f6d672e6f72"
    "672f434f5242412f446174614f757470757453747265616d3a312e300000"
    "00000011446174614f757470757453747265616d00000002000000000000"
    "0000";
    _marshaller_CORBA_DataInputStream = new _Marshaller_CORBA_DataInputStream;
    CORBA::_tc_DataInputStream =
    "000000000000001d00000050000000000000002649444c3a6f6d672e6f72"
    "672f434f5242412f44617461496e70757453747265616d3a312e30000000"
    "0000001044617461496e70757453747265616d0000020000000000000000"
    "0000";
  }
};

static __tc_init_VALUETYPE __init_VALUETYPE;
# 32 "orb_all.cc" 2
# 1 "policy2.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "policy2.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "policy2.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "policy2.cc" 2





namespace MICOPolicy { const CORBA::ULong TRANSPORTPREF_POLICY_TYPE = 1000; }




namespace MICOPolicy { CORBA::TypeCodeConst TransportPrefPolicy::_tc_ProfileTag; }





namespace MICOPolicy { CORBA::TypeCodeConst TransportPrefPolicy::_tc_ProfileTagSeq; }






MICOPolicy::TransportPrefPolicy::~TransportPrefPolicy()
{
}

void *MICOPolicy::TransportPrefPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/MICOPolicy/TransportPrefPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

MICOPolicy::TransportPrefPolicy_ptr MICOPolicy::TransportPrefPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/MICOPolicy/TransportPrefPolicy:1.0" )))
      return _duplicate( (MICOPolicy::TransportPrefPolicy_ptr) _p );
  }
  return _nil();
}

MICOPolicy::TransportPrefPolicy_ptr
MICOPolicy::TransportPrefPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace BiDirPolicy { CORBA::TypeCodeConst _tc_BidirectionalPolicyValue; }





namespace BiDirPolicy { const CORBA::UShort NORMAL = 0; }




namespace BiDirPolicy { const CORBA::UShort BOTH = 1; }




namespace BiDirPolicy { const CORBA::ULong BIDIRECTIONAL_POLICY_TYPE = 37; }





BiDirPolicy::BidirectionalPolicy::~BidirectionalPolicy()
{
}

void *BiDirPolicy::BidirectionalPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/BiDirPolicy/BidirectionalPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

BiDirPolicy::BidirectionalPolicy_ptr BiDirPolicy::BidirectionalPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/BiDirPolicy/BidirectionalPolicy:1.0" )))
      return _duplicate( (BiDirPolicy::BidirectionalPolicy_ptr) _p );
  }
  return _nil();
}

BiDirPolicy::BidirectionalPolicy_ptr
BiDirPolicy::BidirectionalPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}


struct __tc_init_POLICY2 {
  __tc_init_POLICY2()
  {
    MICOPolicy::TransportPrefPolicy::_tc_ProfileTag =
    "010000001500000058000000010000003a00000049444c3a6f6d672e6f72"
    "672f4d49434f506f6c6963792f5472616e73706f727450726566506f6c69"
    "63792f50726f66696c655461673a312e300000000b00000050726f66696c"
    "65546167000005000000";
    MICOPolicy::TransportPrefPolicy::_tc_ProfileTagSeq =
    "0100000015000000cc000000010000003d00000049444c3a6f6d672e6f72"
    "672f4d49434f506f6c6963792f5472616e73706f727450726566506f6c69"
    "63792f50726f66696c655461675365713a312e30000000000e0000005072"
    "6f66696c6554616753657100000013000000680000000100000015000000"
    "58000000010000003a00000049444c3a6f6d672e6f72672f4d49434f506f"
    "6c6963792f5472616e73706f727450726566506f6c6963792f50726f6669"
    "6c655461673a312e300000000b00000050726f66696c6554616700000500"
    "000000000000";
    BiDirPolicy::_tc_BidirectionalPolicyValue =
    "010000001500000064000000010000003500000049444c3a6f6d672e6f72"
    "672f4269446972506f6c6963792f4269646972656374696f6e616c506f6c"
    "69637956616c75653a312e3000000000190000004269646972656374696f"
    "6e616c506f6c69637956616c75650000000004000000";
  }
};

static __tc_init_POLICY2 __init_POLICY2;
# 33 "orb_all.cc" 2
# 1 "dynany_impl.cc" 1
# 26 "dynany_impl.cc"
# 1 "/opt/gcc3/include/g++-v3/strstream.h" 1 3
# 27 "dynany_impl.cc" 2
# 1 "../include/CORBA-SMALL.h" 1
# 28 "dynany_impl.cc" 2
# 1 "../include/mico/dynany_impl.h" 1
# 29 "dynany_impl.cc" 2
# 1 "../include/mico/impl.h" 1
# 30 "dynany_impl.cc" 2
# 1 "../include/mico/throw.h" 1
# 31 "dynany_impl.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 32 "dynany_impl.cc" 2
# 1 "../include/mico/util.h" 1
# 33 "dynany_impl.cc" 2





DynAny_impl::DynAny_impl ()
    : _index (0)
{
}

DynAny_impl::~DynAny_impl ()
{
}

DynamicAny::DynAnyFactory_ptr
DynAny_impl::_factory ()
{
    static DynamicAny::DynAnyFactory_ptr factory =
        DynamicAny::DynAnyFactory::_nil();

    if (CORBA::is_nil (factory)) {
        CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
        CORBA::Object_var obj =
            orb->resolve_initial_references ("DynAnyFactory");
        factory = DynamicAny::DynAnyFactory::_narrow (obj);
        ((void) ((!CORBA::is_nil (factory)) ? 0 : (__assert_fail ("!CORBA::is_nil (factory)", "dynany_impl.cc", 58, __PRETTY_FUNCTION__), 0)));
    }
    return factory;
}

void
DynAny_impl::update_element (CORBA::Long idx)
{
}

void
DynAny_impl::assign (DynamicAny::DynAny_ptr dyn_any)
{
    CORBA::TypeCode_var tc = dyn_any->type();
    if (!tc->equivalent (_type.in()))
        mico_throw (TypeMismatch());

    CORBA::Any_var a = dyn_any->to_any ();
    from_any (a.in());
}

DynamicAny::DynAny_ptr
DynAny_impl::copy ()
{
    CORBA::Any_var a = to_any ();
    return _factory()->create_dyn_any (a.in());
}

CORBA::TypeCode_ptr
DynAny_impl::type ()
{
    return CORBA::TypeCode::_duplicate (_type);
}

void
DynAny_impl::destroy ()
{
    for (CORBA::ULong i = 0; i < _elements.size(); ++i)
        _elements[i]->destroy();
    _elements.erase (_elements.begin(), _elements.end());
    CORBA::release (this);
}

void
DynAny_impl::insert_boolean (CORBA::Boolean value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= CORBA::Any::from_boolean (value);
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_octet (CORBA::Octet value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= CORBA::Any::from_octet (value);
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_char (CORBA::Char value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= CORBA::Any::from_char (value);
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_wchar (CORBA::WChar value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= CORBA::Any::from_wchar (value);
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_short (CORBA::Short value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_ushort (CORBA::UShort value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_long (CORBA::Long value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_longlong (CORBA::LongLong value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_ulong (CORBA::ULong value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_ulonglong (CORBA::ULongLong value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_float (CORBA::Float value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_double (CORBA::Double value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_longdouble (CORBA::LongDouble value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_string (const char* value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    CORBA::TypeCode_ptr utc = tc->unalias();

    if (utc->kind() == CORBA::tk_string &&
        utc->length() > 0 &&
        utc->length() < strlen (value))
        mico_throw (InvalidValue());

    a.set_type (tc);
    a <<= CORBA::Any::from_string ((char *)value, utc->length());
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_wstring (const CORBA::WChar* value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    CORBA::TypeCode_ptr utc = tc->unalias();

    if (utc->kind() == CORBA::tk_wstring &&
        utc->length() > 0 &&
        utc->length() < xwcslen (value))
        mico_throw (InvalidValue());

    a.set_type (tc);
    a <<= CORBA::Any::from_wstring ((CORBA::WChar *)value, utc->length());
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_reference (CORBA::Object_ptr value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    if (_type->unalias()->kind() == CORBA::tk_objref)
        a <<= CORBA::Any::from_object (value, _type->name());
    else
        a <<= CORBA::Any::from_object (value, "");
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_typecode (CORBA::TypeCode_ptr value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_val (CORBA::ValueBase *value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);

    CORBA::StaticAny sa (CORBA::_stc_ValueBase, &value);

    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();

    if (!a.from_static_any (sa, tc))
        mico_throw (TypeMismatch());

    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_any (const CORBA::Any &value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any a;

    CORBA::TypeCode_var tc = _elements[_index]->type();
    a.set_type (tc);
    a <<= value;
    _elements[_index]->from_any (a);
}

void
DynAny_impl::insert_dyn_any (DynamicAny::DynAny_ptr value)
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    CORBA::Any_var a = value->to_any();
    insert_any (a.in());
}

void
DynAny_impl::insert_abstract (CORBA::AbstractBase * value)
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "dynany_impl.cc", 421, __PRETTY_FUNCTION__), 0)));
}

CORBA::Boolean
DynAny_impl::get_boolean ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Boolean value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_boolean (value)))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Octet
DynAny_impl::get_octet ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Octet value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_octet (value)))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Char
DynAny_impl::get_char ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Char value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_char (value)))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::WChar
DynAny_impl::get_wchar ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::WChar value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_wchar (value)))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Short
DynAny_impl::get_short ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Short value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::UShort
DynAny_impl::get_ushort ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::UShort value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Long
DynAny_impl::get_long ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Long value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::LongLong
DynAny_impl::get_longlong ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::LongLong value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::ULong
DynAny_impl::get_ulong ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::ULong value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::ULongLong
DynAny_impl::get_ulonglong ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::ULongLong value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Float
DynAny_impl::get_float ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Float value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::Double
DynAny_impl::get_double ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Double value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

CORBA::LongDouble
DynAny_impl::get_longdouble ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::LongDouble value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return value;
}

char*
DynAny_impl::get_string ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    const char *value;
    CORBA::TypeCode_var tc = a->type();
    if (!((CORBA::Any &)a >>= CORBA::Any::to_string (value, tc->unalias()->length())))
        mico_throw (TypeMismatch ());
    return CORBA::string_dup (value);
}

CORBA::WChar*
DynAny_impl::get_wstring ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    const CORBA::WChar *value;
    CORBA::TypeCode_var tc = a->type();
    if (!((CORBA::Any &)a >>= CORBA::Any::to_wstring (value, tc->unalias()->length())))
        mico_throw (TypeMismatch ());
    return CORBA::wstring_dup (value);
}

CORBA::Object_ptr
DynAny_impl::get_reference ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::Object_var value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_object (value)))
        mico_throw (TypeMismatch ());
    return CORBA::Object::_duplicate (value);
}

CORBA::TypeCode_ptr
DynAny_impl::get_typecode ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::TypeCode_ptr value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return CORBA::TypeCode::_duplicate (value);
}

CORBA::Any*
DynAny_impl::get_any ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    const CORBA::Any *value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    CORBA::Any *retn = new CORBA::Any;
    *retn = *value;
    return retn;
}

DynamicAny::DynAny_ptr
DynAny_impl::get_dyn_any ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    const CORBA::Any* value;
    if (!((CORBA::Any &)a >>= value))
        mico_throw (TypeMismatch ());
    return _factory()->create_dyn_any (*value);
}

CORBA::ValueBase *
DynAny_impl::get_val ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();

    CORBA::ValueBase *value;
    CORBA::StaticAny sa (CORBA::_stc_ValueBase, &value);

    if (!a->to_static_any (sa))
        mico_throw (TypeMismatch());

    return value;
}

CORBA::AbstractBase *
DynAny_impl::get_abstract ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    update_element (_index);
    CORBA::Any_var a = _elements[_index]->to_any();
    CORBA::AbstractBase * value;
    if (!((CORBA::Any &)a >>= CORBA::Any::to_abstract_base (value)))
        mico_throw (TypeMismatch ());
    return value;
}

DynamicAny::DynAny_ptr
DynAny_impl::current_component ()
{
    if (_index < 0) {
        if (component_count() == 0)
            mico_throw (TypeMismatch());
        return DynamicAny::DynAny::_nil();
    }
    update_element (_index);
    return DynamicAny::DynAny::_duplicate (_elements[_index]);
}

CORBA::ULong
DynAny_impl::component_count ()
{
    return _elements.size();
}

CORBA::Boolean
DynAny_impl::next ()
{
    if ((CORBA::ULong)_index+1 == _elements.size())
        return 0;
    ++_index;
    return 1;
}

CORBA::Boolean
DynAny_impl::seek (CORBA::Long index)
{
    if (index < 0) {
        _index = -1;
        return 0;
    }
    update_element (index);
    if ((CORBA::ULong)index >= _elements.size()) {
        _index = -1;
        return 0;
    }
    _index = index;
    return 1;
}

void
DynAny_impl::rewind ()
{
    seek (0);
}

CORBA::Boolean
DynAny_impl::equal (DynamicAny::DynAny_ptr da)
{
    CORBA::Any_var me = to_any();
    CORBA::Any_var he = da->to_any();
    return me.in() == he.in();
}





DynBasic_impl::DynBasic_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);

    _value.set_type (_type);
    tc = tc->unalias ();
    switch (tc->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:
        break;
    case CORBA::tk_char:
        _value <<= CORBA::Any::from_char (0);
        break;
    case CORBA::tk_wchar:
        _value <<= CORBA::Any::from_wchar (0);
        break;
    case CORBA::tk_boolean:
        _value <<= CORBA::Any::from_boolean (0);
        break;
    case CORBA::tk_octet:
        _value <<= CORBA::Any::from_octet (0);
        break;
    case CORBA::tk_short:
        _value <<= (CORBA::Short)0;
        break;
    case CORBA::tk_ushort:
        _value <<= (CORBA::UShort)0;
        break;
    case CORBA::tk_long:
        _value <<= (CORBA::Long)0;
        break;
    case CORBA::tk_longlong:
        _value <<= (CORBA::LongLong)0;
        break;
    case CORBA::tk_ulong:
        _value <<= (CORBA::ULong)0;
        break;
    case CORBA::tk_ulonglong:
        _value <<= (CORBA::ULongLong)0;
        break;
    case CORBA::tk_float:
        _value <<= (CORBA::Float)0;
        break;
    case CORBA::tk_double:
        _value <<= (CORBA::Double)0;
        break;
    case CORBA::tk_longdouble:
        _value <<= (CORBA::LongDouble)0;
        break;
    case CORBA::tk_any:
        _value <<= CORBA::Any();
        break;
    case CORBA::tk_TypeCode:
        _value <<= CORBA::_tc_null;
        break;
    case CORBA::tk_objref:
        _value <<= CORBA::Any::from_object (CORBA::Object::_nil(), "");
        break;
    case CORBA::tk_string:
        _value <<= "";
        break;
    case CORBA::tk_wstring:
        _value <<= L"";
        break;
    default:
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    }
    _elements.push_back (_duplicate (this));
}

DynBasic_impl::DynBasic_impl (const CORBA::Any &a)
{
    _value = a;
    _type = _value.type();

    switch (_type->unalias()->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:
    case CORBA::tk_char:
    case CORBA::tk_wchar:
    case CORBA::tk_boolean:
    case CORBA::tk_octet:
    case CORBA::tk_short:
    case CORBA::tk_ushort:
    case CORBA::tk_long:
    case CORBA::tk_longlong:
    case CORBA::tk_ulong:
    case CORBA::tk_ulonglong:
    case CORBA::tk_float:
    case CORBA::tk_double:
    case CORBA::tk_longdouble:
    case CORBA::tk_any:
    case CORBA::tk_TypeCode:
    case CORBA::tk_objref:
    case CORBA::tk_string:
    case CORBA::tk_wstring:
        break;
    default:
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    }
    _elements.push_back (_duplicate (this));
}

DynBasic_impl::~DynBasic_impl ()
{
}

void
DynBasic_impl::destroy ()
{
    _elements.pop_back ();
    CORBA::release (this);
}

void
DynBasic_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (_type->unalias()->kind() != CORBA::tk_objref ||
        tc->unalias()->kind() != CORBA::tk_objref) {
        if (!_type->equaltype (tc))
            mico_throw (TypeMismatch ());
    }
    _value = value;
}

CORBA::Any*
DynBasic_impl::to_any ()
{
    return new CORBA::Any (_value);
}





DynFixed_impl::DynFixed_impl (CORBA::TypeCode_ptr tc)
{
    if (tc->unalias()->kind() != CORBA::tk_fixed)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    _type = CORBA::TypeCode::_duplicate (tc);

    CORBA::UShort digits = _type->unalias()->fixed_digits();
    CORBA::Short scale = _type->unalias()->fixed_scale();

    Fixed f (digits, scale);

    _value <<= CORBA::Any::from_fixed (f, digits, scale);

    _elements.push_back (_duplicate (this));

    _index = -1;
}

DynFixed_impl::DynFixed_impl (const CORBA::Any &a)
{
    _value = a;
    _type = a.type();
    if (_type->unalias()->kind() != CORBA::tk_fixed)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    _elements.push_back (_duplicate (this));

    _index = -1;
}

DynFixed_impl::~DynFixed_impl ()
{
}

void
DynFixed_impl::destroy ()
{
    _elements.pop_back ();
    CORBA::release (this);
}

void
DynFixed_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());
    _value = value;
}

CORBA::Any*
DynFixed_impl::to_any ()
{
    return new CORBA::Any (_value);
}

char *
DynFixed_impl::get_value ()
{
    CORBA::UShort digits = _type->unalias()->fixed_digits();
    CORBA::Short scale = _type->unalias()->fixed_scale();

    Fixed f (digits, scale);

    CORBA::Boolean r = (_value >>= CORBA::Any::to_fixed (f, digits, scale));
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 989, __PRETTY_FUNCTION__), 0)));

    ostrstream ostr;
    ostr << f << ends;
    char *out = CORBA::string_dup (ostr.str());
    ostr.rdbuf()->freeze (0);

    return out;
}

void
DynFixed_impl::set_value (const char *in)
{
    CORBA::UShort digits = _type->unalias()->fixed_digits();
    CORBA::Short scale = _type->unalias()->fixed_scale();

    Fixed f (digits, scale);

    istrstream istr (in);

    istr >> f;

    _value <<= CORBA::Any::from_fixed (f, digits, scale);
}





DynEnum_impl::DynEnum_impl (CORBA::TypeCode_ptr tc)
{
    if (tc->unalias()->kind() != CORBA::tk_enum)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    _type = CORBA::TypeCode::_duplicate (tc);
    _value.set_type (tc);
    _value.enum_put (0);

    _elements.push_back (_duplicate (this));

    _index = -1;
}

DynEnum_impl::DynEnum_impl (const CORBA::Any &a)
{
    _value = a;
    _type = a.type();
    if (_type->unalias()->kind() != CORBA::tk_enum)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    _elements.push_back (_duplicate (this));

    _index = -1;
}

DynEnum_impl::~DynEnum_impl ()
{
}

void
DynEnum_impl::destroy ()
{
    _elements.pop_back ();
    CORBA::release (this);
}

void
DynEnum_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());
    _value = value;
}

CORBA::Any*
DynEnum_impl::to_any ()
{
    return new CORBA::Any (_value);
}

char*
DynEnum_impl::get_as_string ()
{
    return CORBA::string_dup (
        _type->unalias()->member_name (get_as_ulong()));
}

void
DynEnum_impl::set_as_string (const char* value)
{
    CORBA::TypeCode_ptr tc = _type->unalias();
    CORBA::Long idx = tc->member_index (value);
    if (idx < 0)
        mico_throw (InvalidValue());
    CORBA::Boolean r = _value.enum_put (idx);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1085, __PRETTY_FUNCTION__), 0)));
}

CORBA::ULong
DynEnum_impl::get_as_ulong ()
{
    CORBA::ULong l;
    CORBA::Boolean r = _value.enum_get (l);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1093, __PRETTY_FUNCTION__), 0)));
    return l;
}

void
DynEnum_impl::set_as_ulong (CORBA::ULong value)
{
    if (value >= _type->unalias()->member_count())
        mico_throw (InvalidValue());
    CORBA::Boolean r = _value.enum_put (value);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1103, __PRETTY_FUNCTION__), 0)));
}





DynStruct_impl::DynStruct_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias();
    if (tc->kind() != CORBA::tk_struct && tc->kind() != CORBA::tk_except)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    _isexcept = (tc->kind() == CORBA::tk_except);
    for (CORBA::ULong i = 0; i < tc->member_count(); ++i) {
        CORBA::TypeCode_var memtc = tc->member_type(i);
        _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));
    }
    if (_elements.size() == 0)
        _index = -1;
}

DynStruct_impl::DynStruct_impl (const CORBA::Any &a)
{
    _type = a.type();
    CORBA::TypeCode_ptr tc = _type->unalias();
    if (tc->kind() != CORBA::tk_struct && tc->kind() != CORBA::tk_except)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    _isexcept = (tc->kind() == CORBA::tk_except);

    if (_isexcept) {
        CORBA::String_var repoid;
        CORBA::Boolean r = a.except_get_begin (repoid.out());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1136, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = a.struct_get_begin ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1139, __PRETTY_FUNCTION__), 0)));
    }
    for (CORBA::ULong i = 0; i < tc->member_count(); ++i) {
        CORBA::Any el;
        CORBA::Boolean r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1144, __PRETTY_FUNCTION__), 0)));



         CORBA::TypeCode_var member_tc = tc->member_type(i);
         el.type(member_tc);

        _elements.push_back (_factory()->create_dyn_any (el));
    }
    if (_isexcept) {
        CORBA::Boolean r = a.except_get_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1155, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = a.struct_get_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1158, __PRETTY_FUNCTION__), 0)));
    }
    if (_elements.size() == 0)
        _index = -1;
}

DynStruct_impl::~DynStruct_impl ()
{
}

void
DynStruct_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    if (_isexcept) {
        CORBA::String_var repoid;
        CORBA::Boolean r = value.except_get_begin (repoid.out());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1178, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = value.struct_get_begin ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1181, __PRETTY_FUNCTION__), 0)));
    }
    CORBA::TypeCode_ptr tc2 = tc->unalias();
    for (CORBA::ULong i = 0; i < tc2->member_count(); ++i) {
        CORBA::Any el;
        CORBA::Boolean r = value.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1187, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc2->member_type(i);
        el.type(member_tc);

        _elements[i]->from_any (el);
    }
    if (_isexcept) {
        CORBA::Boolean r = value.except_get_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1198, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = value.struct_get_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1201, __PRETTY_FUNCTION__), 0)));
    }
}

CORBA::Any*
DynStruct_impl::to_any ()
{
    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);

    if (_isexcept) {
        CORBA::TypeCode_ptr tc = _type->unalias();
        CORBA::Boolean r = a->except_put_begin (tc->id());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1215, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = a->struct_put_begin ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1218, __PRETTY_FUNCTION__), 0)));
    }
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        CORBA::Any_var el = _elements[i]->to_any ();
        CORBA::Boolean r = a->any_put (el.inout());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1223, __PRETTY_FUNCTION__), 0)));
    }
    if (_isexcept) {
        CORBA::Boolean r = a->except_put_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1227, __PRETTY_FUNCTION__), 0)));
    } else {
        CORBA::Boolean r = a->struct_put_end ();
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1230, __PRETTY_FUNCTION__), 0)));
    }
    return a;
}

DynamicAny::FieldName
DynStruct_impl::current_member_name ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());
    return CORBA::string_dup (_type->unalias()->member_name (_index));
}

CORBA::TCKind
DynStruct_impl::current_member_kind ()
{
    if (_index < 0)
        mico_throw (TypeMismatch());

    CORBA::TypeCode_var tc = _type->unalias()->member_type (_index);
    return tc->kind();
}

DynamicAny::NameValuePairSeq*
DynStruct_impl::get_members ()
{
    DynamicAny::NameValuePairSeq *seq = new DynamicAny::NameValuePairSeq;
    seq->length (_elements.size());
    CORBA::TypeCode_ptr tc = _type->unalias ();
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        (*seq)[i].id = tc->member_name (i);
        CORBA::Any_var a = _elements[i]->to_any ();
        (*seq)[i].value = a.in();
    }
    return seq;
}

void
DynStruct_impl::set_members (const DynamicAny::NameValuePairSeq& value)
{
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (value.length() != tc->member_count())
        mico_throw (InvalidValue ());

    for (CORBA::ULong i = 0; i < value.length(); ++i) {
        if (strcmp (tc->member_name(i), value[i].id))
            mico_throw (TypeMismatch ());
        _elements[i]->from_any (value[i].value);
    }
    _index = _elements.size() > 0 ? 0 : -1;
}

DynamicAny::NameDynAnyPairSeq*
DynStruct_impl::get_members_as_dyn_any ()
{
    DynamicAny::NameDynAnyPairSeq *seq = new DynamicAny::NameDynAnyPairSeq;
    seq->length (_elements.size());
    CORBA::TypeCode_ptr tc = _type->unalias ();
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        (*seq)[i].id = tc->member_name (i);
        (*seq)[i].value = _elements[i]->copy();
    }
    return seq;
}

void
DynStruct_impl::set_members_as_dyn_any (
    const DynamicAny::NameDynAnyPairSeq& value)
{
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (value.length() != tc->member_count())
        mico_throw (InvalidValue ());

    for (CORBA::ULong i = 0; i < value.length(); ++i) {
        if (strlen (value[i].id) > 0 &&
            strcmp (tc->member_name(i), value[i].id))
            mico_throw (TypeMismatch ());
        _elements[i]->assign (value[i].value.in());
    }
    _index = _elements.size() > 0 ? 0 : -1;
}





DynUnion_impl::DynUnion_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias ();
    if (tc->kind() != CORBA::tk_union)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::TypeCode_var disctc = tc->discriminator_type();
    _elements.push_back (_factory()->create_dyn_any_from_type_code (disctc));
    CORBA::Any_var disc = _elements[0]->to_any ();
    _member_idx = tc->member_index (disc.in());
    if (_member_idx >= 0) {
        CORBA::TypeCode_var memtc = tc->member_type (_member_idx);
        _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));
    } else {

    }
}

DynUnion_impl::DynUnion_impl (const CORBA::Any &a)
{
    _type = a.type();
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (tc->kind() != CORBA::tk_union)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::Boolean r = a.union_get_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1343, __PRETTY_FUNCTION__), 0)));
    CORBA::Any disc;
    r = a.any_get (disc);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1346, __PRETTY_FUNCTION__), 0)));



    CORBA::TypeCode_var discr_tc = tc->discriminator_type();
    disc.type(discr_tc);

    _elements.push_back (_factory()->create_dyn_any (disc));
    _member_idx = tc->member_index (disc);
    if (_member_idx >= 0) {
        r = a.union_get_selection (_member_idx);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1357, __PRETTY_FUNCTION__), 0)));
        CORBA::Any el;
        r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1360, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->member_type(_member_idx);
        el.type(member_tc);

        _elements.push_back (_factory()->create_dyn_any (el));
    } else {

    }
    r = a.union_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1372, __PRETTY_FUNCTION__), 0)));
}

DynUnion_impl::~DynUnion_impl ()
{
}

void
DynUnion_impl::update_element (CORBA::Long idx)
{
    if (idx != 1)
        return;


    CORBA::Any_var disc = _elements[0]->to_any ();
    CORBA::Long nidx = _type->unalias()->member_index (disc.in());
    if (nidx == _member_idx)
        return;

    if (_elements.size() == 2)
        _elements.pop_back ();
    if (nidx >= 0) {
        CORBA::TypeCode_var tc = _type->unalias()->member_type (nidx);
        _elements.push_back (_factory()->create_dyn_any_from_type_code (tc));
    } else {

    }
    _member_idx = nidx;

    if (_index >= (CORBA::Long)_elements.size())
        _index = _elements.size()-1;
}

CORBA::ULong
DynUnion_impl::component_count ()
{
    update_element (1);
    return _elements.size();
}

void
DynUnion_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    CORBA::Boolean r = value.union_get_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1420, __PRETTY_FUNCTION__), 0)));
    CORBA::Any disc;
    r = value.any_get (disc);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1423, __PRETTY_FUNCTION__), 0)));



    CORBA::TypeCode_var discr_tc = tc->discriminator_type();
    disc.type(discr_tc);

    _elements[0]->from_any (disc);
    update_element (1);
    if (_member_idx >= 0) {
        r = value.union_get_selection (_member_idx);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1434, __PRETTY_FUNCTION__), 0)));
        CORBA::Any el;
        r = value.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1437, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->member_type(_member_idx);
        el.type(member_tc);

        _elements[1]->from_any (el);
    } else {

    }
    r = value.union_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1449, __PRETTY_FUNCTION__), 0)));
}

CORBA::Any*
DynUnion_impl::to_any ()
{
    if (has_default_member())
        set_to_default_member ();

    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);
    CORBA::Boolean r = a->union_put_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1462, __PRETTY_FUNCTION__), 0)));
    CORBA::Any_var disc = _elements[0]->to_any ();
    r = a->any_put (disc.inout());
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1465, __PRETTY_FUNCTION__), 0)));
    CORBA::Long idx = _type->unalias()->member_index (disc.in());
    update_element (1);
    if (idx >= 0) {
        r = a->union_put_selection (idx);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1470, __PRETTY_FUNCTION__), 0)));
        CORBA::Any_var val = _elements[1]->to_any ();
        r = a->any_put (val.inout());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1473, __PRETTY_FUNCTION__), 0)));
    }
    r = a->union_put_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1476, __PRETTY_FUNCTION__), 0)));
    return a;
}

DynamicAny::DynAny_ptr
DynUnion_impl::get_discriminator ()
{
    return DynamicAny::DynAny::_duplicate (_elements[0]);
}

void
DynUnion_impl::set_discriminator (DynamicAny::DynAny_ptr d)
{
    _elements[0]->assign (d);
}

CORBA::TCKind
DynUnion_impl::discriminator_kind ()
{

    CORBA::TypeCode_var tc = _elements[0]->type();
    return tc->kind();
}

CORBA::Boolean
DynUnion_impl::has_default_member ()
{
    CORBA::Any_var disc = _elements[0]->to_any ();
    CORBA::Long idx = _type->unalias()->member_index (disc.in());
    return idx < 0 || idx == _type->unalias()->default_index();
}

void
DynUnion_impl::set_to_default_member ()
{
    CORBA::TypeCode_ptr tc = _type->unalias();
    CORBA::Long defidx = tc->default_index();

    CORBA::TypeCode_var disc = tc->discriminator_type();
    disc = CORBA::TypeCode::_duplicate (disc->unalias());

    if (disc->kind() == CORBA::tk_enum) {
        CORBA::Any any;
        any.set_type (disc);
        for (CORBA::ULong i = 0; i < disc->member_count(); ++i) {
            CORBA::Boolean r = any.enum_put (i);
            ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1522, __PRETTY_FUNCTION__), 0)));
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        }
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_long) {
        CORBA::Long l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_longlong) {
        CORBA::LongLong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ulong) {
        CORBA::ULong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ulonglong) {
        CORBA::ULongLong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_char) {
        CORBA::Char l = 0;
        CORBA::Any any;
        do {
            any <<= CORBA::Any::from_char (l);
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_wchar) {
        CORBA::WChar l = 0;
        CORBA::Any any;
        do {
            any <<= CORBA::Any::from_wchar (l);
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_short) {
        CORBA::Short l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ushort) {



            CORBA::UShort l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) == defidx) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_boolean) {
        CORBA::Any any;
        any <<= CORBA::Any::from_boolean (1);
        if (tc->member_index (any) == defidx) {
            _elements[0]->from_any (any);
            _index = 0;
            return;
        }
        any <<= CORBA::Any::from_boolean (0);
        if (tc->member_index (any) == defidx) {
            _elements[0]->from_any (any);
            _index = 0;
            return;
        }
        mico_throw (TypeMismatch());
    }
}

void
DynUnion_impl::set_to_no_active_member ()
{
    CORBA::TypeCode_ptr tc = _type->unalias();
    CORBA::Long defidx = tc->default_index();

    CORBA::TypeCode_var disc = tc->discriminator_type();
    disc = CORBA::TypeCode::_duplicate (disc->unalias());

    if (defidx >= 0)
        mico_throw (TypeMismatch());

    if (disc->kind() == CORBA::tk_enum) {
        CORBA::Any any;
        any.set_type (disc);
        for (CORBA::ULong i = 0; i < disc->member_count(); ++i) {
            CORBA::Boolean r = any.enum_put (i);
            ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1673, __PRETTY_FUNCTION__), 0)));
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        }
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_long) {
        CORBA::Long l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_longlong) {
        CORBA::LongLong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ulong) {
        CORBA::ULong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ulonglong) {
        CORBA::ULongLong l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_char) {
        CORBA::Char l = 0;
        CORBA::Any any;
        do {
            any <<= CORBA::Any::from_char (l);
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_wchar) {
        CORBA::WChar l = 0;
        CORBA::Any any;
        do {
            any <<= CORBA::Any::from_wchar (l);
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_short) {
        CORBA::Short l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_ushort) {



            CORBA::UShort l = 0;
        CORBA::Any any;
        do {
            any <<= l;
            if (tc->member_index (any) < 0) {
                _elements[0]->from_any (any);
                _index = 0;
                return;
            }
        } while (++l);
        mico_throw (TypeMismatch());
    }
    if (disc->kind() == CORBA::tk_boolean) {
        CORBA::Any any;
        any <<= CORBA::Any::from_boolean (1);
        if (tc->member_index (any) < 0) {
            _elements[0]->from_any (any);
            _index = 0;
            return;
        }
        any <<= CORBA::Any::from_boolean (0);
        if (tc->member_index (any) < 0) {
            _elements[0]->from_any (any);
            _index = 0;
            return;
        }
        mico_throw (TypeMismatch());
    }
}

CORBA::Boolean
DynUnion_impl::has_no_active_member ()
{
    CORBA::TypeCode_ptr tc = _type->unalias();
    CORBA::Long defidx = tc->default_index();

    if (defidx >= 0)
        return 0;

    update_element (1);
    return _elements.size() == 1;
}

DynamicAny::FieldName
DynUnion_impl::member_name ()
{
    if (component_count() == 1)
        mico_throw (InvalidValue());
    CORBA::Any_var disc = _elements[0]->to_any ();
    CORBA::Long idx = _type->unalias()->member_index (disc.in());
    ((void) ((idx >= 0) ? 0 : (__assert_fail ("idx >= 0", "dynany_impl.cc", 1827, __PRETTY_FUNCTION__), 0)));
    return CORBA::string_dup (_type->unalias()->member_name (idx));
}

DynamicAny::DynAny_ptr
DynUnion_impl::member ()
{
    update_element (1);
    if (_elements.size() == 1)
        mico_throw (InvalidValue());
    return DynamicAny::DynAny::_duplicate (_elements[1]);
}

CORBA::TCKind
DynUnion_impl::member_kind ()
{

    update_element (1);
    if (_elements.size() == 1)
        mico_throw (InvalidValue());
    CORBA::TypeCode_var tc = _elements[1]->type();
    return tc->kind();
}





DynSequence_impl::DynSequence_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias ();
    if (tc->kind() != CORBA::tk_sequence)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    _length = 0;
    _index = -1;
}

DynSequence_impl::DynSequence_impl (const CORBA::Any &a)
{
    _type = a.type ();
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (tc->kind() != CORBA::tk_sequence)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::Boolean r = a.seq_get_begin (_length);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1873, __PRETTY_FUNCTION__), 0)));
    for (CORBA::ULong i = 0; i < _length; ++i) {
        CORBA::Any el;
        r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1877, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->content_type();
        el.type(member_tc);

        _elements.push_back (_factory()->create_dyn_any (el));
    }
    r = a.seq_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1887, __PRETTY_FUNCTION__), 0)));

    if (_elements.size() == 0)
        _index = -1;
}

DynSequence_impl::~DynSequence_impl ()
{
}

void
DynSequence_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    CORBA::ULong len;
    CORBA::Boolean r = value.seq_get_begin (len);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1906, __PRETTY_FUNCTION__), 0)));
    if (len != _length)
        set_length (len);
    for (CORBA::ULong i = 0; i < _length; ++i) {
        CORBA::Any el;
        r = value.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1912, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->unalias()->content_type();
        el.type(member_tc);

        _elements[i]->from_any (el);
    }
    r = value.seq_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1922, __PRETTY_FUNCTION__), 0)));
}

CORBA::Any*
DynSequence_impl::to_any ()
{
    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);
    CORBA::Boolean r = a->seq_put_begin (_length);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1932, __PRETTY_FUNCTION__), 0)));
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        CORBA::Any_var el = _elements[i]->to_any();
        r = a->any_put (el.inout());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1936, __PRETTY_FUNCTION__), 0)));
    }
    r = a->seq_put_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 1939, __PRETTY_FUNCTION__), 0)));
    return a;
}

CORBA::ULong
DynSequence_impl::get_length ()
{
    return _length;
}

void
DynSequence_impl::set_length (CORBA::ULong value)
{
    CORBA::TypeCode_ptr utc = _type->unalias();

    if (utc->length() > 0 && value > utc->length())
        mico_throw (InvalidValue());

    if (value < _elements.size ()) {
        _elements.erase (_elements.begin() + value, _elements.end());
        if (value == 0)
            _index = -1;
        else if (_index >= (CORBA::Long)value)
            _index = -1;
    } else if (value > _elements.size()) {
        CORBA::TypeCode_var tc = _type->unalias()->content_type ();
        for (CORBA::ULong i = 0; i < value - _length; ++i)
            _elements.push_back (
                _factory()->create_dyn_any_from_type_code (tc.in()));
        if (_index < 0)
            _index = _length;
    }
    _length = value;
}

DynamicAny::AnySeq*
DynSequence_impl::get_elements ()
{
    DynamicAny::AnySeq *seq = new DynamicAny::AnySeq;
    seq->length (_length);

    for (CORBA::ULong i = 0; i < _length; ++i) {
        CORBA::Any_var el = _elements[i]->to_any ();
        (*seq)[i] = el.in();
    }
    return seq;
}

void
DynSequence_impl::set_elements (const DynamicAny::AnySeq& value)
{
    CORBA::TypeCode_ptr utc = _type->unalias();

    if (utc->length() > 0 && value.length() > utc->length())
        mico_throw (InvalidValue());

    _elements.erase (_elements.begin(), _elements.end());
    for (CORBA::ULong i = 0; i < value.length(); ++i)
        _elements.push_back (_factory()->create_dyn_any (value[i]));
    _length = value.length();
    _index = _length > 0 ? 0 : -1;
}

DynamicAny::DynAnySeq*
DynSequence_impl::get_elements_as_dyn_any ()
{
    DynamicAny::DynAnySeq *seq = new DynamicAny::DynAnySeq;
    seq->length (_length);

    for (CORBA::ULong i = 0; i < _length; ++i)
        (*seq)[i] = _elements[i]->copy();
    return seq;
}

void
DynSequence_impl::set_elements_as_dyn_any (const DynamicAny::DynAnySeq& value)
{
    CORBA::TypeCode_ptr utc = _type->unalias();

    if (utc->length() > 0 && value.length() > utc->length())
        mico_throw (InvalidValue());

    _elements.erase (_elements.begin(), _elements.end());
    for (CORBA::ULong i = 0; i < value.length(); ++i)
        _elements.push_back (value[i]->copy());
    _length = value.length();
    _index = _length > 0 ? 0 : -1;
}





DynArray_impl::DynArray_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias();
    if (tc->kind() != CORBA::tk_array)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::ULong len = tc->length();
    CORBA::TypeCode_var eltc = tc->content_type();
    for (CORBA::ULong i = 0; i < len; ++i)
        _elements.push_back (
            _factory()->create_dyn_any_from_type_code (eltc.in()));
}

DynArray_impl::DynArray_impl (const CORBA::Any &a)
{
    _type = a.type ();
    CORBA::TypeCode_ptr tc = _type->unalias();
    if (tc->kind() != CORBA::tk_array)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::ULong len = tc->length();
    CORBA::Boolean r = a.array_get_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2055, __PRETTY_FUNCTION__), 0)));
    for (CORBA::ULong i = 0; i < len; ++i) {
        CORBA::Any el;
        r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2059, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->content_type();
        el.type(member_tc);

        _elements.push_back (_factory()->create_dyn_any (el));
    }
    r = a.array_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2069, __PRETTY_FUNCTION__), 0)));
}

DynArray_impl::~DynArray_impl ()
{
}

void
DynArray_impl::from_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    CORBA::ULong len = tc->unalias()->length();
    CORBA::Boolean r = value.array_get_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2085, __PRETTY_FUNCTION__), 0)));
    for (CORBA::ULong i = 0; i < len; ++i) {
        CORBA::Any el;
        r = value.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2089, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->unalias()->content_type();
        el.type(member_tc);

        _elements[i]->from_any (el);
    }
    r = value.array_get_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2099, __PRETTY_FUNCTION__), 0)));
}

CORBA::Any*
DynArray_impl::to_any ()
{
    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);
    CORBA::Boolean r = a->array_put_begin ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2109, __PRETTY_FUNCTION__), 0)));
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        CORBA::Any_var el = _elements[i]->to_any ();
        r = a->any_put (el.inout());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2113, __PRETTY_FUNCTION__), 0)));
    }
    r = a->array_put_end ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2116, __PRETTY_FUNCTION__), 0)));
    return a;
}

DynamicAny::AnySeq*
DynArray_impl::get_elements ()
{
    DynamicAny::AnySeq *seq = new DynamicAny::AnySeq;
    seq->length (_elements.size());

    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        CORBA::Any_var el = _elements[i]->to_any ();
        (*seq)[i] = el.in();
    }
    return seq;
}

void
DynArray_impl::set_elements (const DynamicAny::AnySeq& value)
{
    if (value.length() != _elements.size())
        mico_throw (TypeMismatch ());

    for (CORBA::ULong i = 0; i < _elements.size(); ++i)
        _elements[i]->from_any (value[i]);
}

DynamicAny::DynAnySeq*
DynArray_impl::get_elements_as_dyn_any ()
{
    DynamicAny::DynAnySeq *seq = new DynamicAny::DynAnySeq;
    seq->length (_elements.size());

    for (CORBA::ULong i = 0; i < _elements.size(); ++i)
        (*seq)[i] = _elements[i]->copy();
    return seq;
}

void
DynArray_impl::set_elements_as_dyn_any (const DynamicAny::DynAnySeq& value)
{
    if (value.length() != _elements.size())
        mico_throw (TypeMismatch ());

    for (CORBA::ULong i = 0; i < _elements.size(); ++i)
        _elements[i]->assign (value[i].in());
}



DynValueCommon_impl::DynValueCommon_impl ()
{
  _is_null = 1;
  _index = -1;
}

CORBA::Boolean
DynValueCommon_impl::is_null ()
{
  return _is_null;
}

void
DynValueCommon_impl::set_to_null ()
{
  _is_null = 1;
  _index = -1;
}

void
DynValueCommon_impl::set_to_value ()
{
  _is_null = 0;
  _index = 0;
}
# 2199 "dynany_impl.cc"
DynValue_impl::DynValue_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias();
    if (tc->kind() != CORBA::tk_value)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    for (CORBA::ULong i = 0; i < tc->member_count_inherited(); ++i) {
        CORBA::TypeCode_var memtc = tc->member_type_inherited(i);
        _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));
    }
    _index = -1;
}

DynValue_impl::DynValue_impl (const CORBA::Any &a)
{
    _type = a.type();
    CORBA::TypeCode_ptr tc = _type->unalias();
    if (tc->kind() != CORBA::tk_value)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::Long value_id;
    CORBA::Boolean is_ref;

    CORBA::Boolean r = a.value_get_begin (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2223, __PRETTY_FUNCTION__), 0)));

    if (is_ref) {

      for (CORBA::ULong i = 0; i < tc->member_count_inherited(); ++i) {
        CORBA::TypeCode_var memtc = tc->member_type_inherited(i);
        _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));
      }

      if (!value_id) {
        _is_null = 1;
        _index = -1;
      }
      else {
        _is_null = 0;

        ((void) ((0) ? 0 : (__assert_fail ("0", "dynany_impl.cc", 2239, __PRETTY_FUNCTION__), 0)));
      }
    }

    _is_null = 0;

    for (CORBA::ULong i = 0; i < tc->member_count_inherited(); ++i) {
        CORBA::Any el;
        r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2248, __PRETTY_FUNCTION__), 0)));



        CORBA::TypeCode_var member_tc = tc->member_type_inherited(i);
        el.type(member_tc);

        _elements.push_back (_factory()->create_dyn_any (el));
    }

    r = a.value_get_end (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2259, __PRETTY_FUNCTION__), 0)));

    if (_elements.size() == 0)
        _index = -1;
}

DynValue_impl::~DynValue_impl ()
{
}

void
DynValue_impl::from_any (const CORBA::Any& a)
{
    CORBA::TypeCode_var tc = a.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    CORBA::Long value_id;
    CORBA::Boolean is_ref;

    CORBA::Boolean r = a.value_get_begin (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2280, __PRETTY_FUNCTION__), 0)));

    if (is_ref) {
      if (!value_id) {
        _is_null = 1;
        return;
      }


      ((void) ((0) ? 0 : (__assert_fail ("0", "dynany_impl.cc", 2289, __PRETTY_FUNCTION__), 0)));
    }

    _is_null = 0;

    CORBA::TypeCode_ptr tc2 = tc->unalias();
    for (CORBA::ULong i = 0; i < tc2->member_count_inherited(); ++i) {
        CORBA::Any el;
        r = a.any_get (el);
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2298, __PRETTY_FUNCTION__), 0)));
        CORBA::TypeCode_var member_tc = tc2->member_type_inherited(i);
        el.type(member_tc);
        _elements[i]->from_any (el);
    }

    r = a.value_get_end (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2305, __PRETTY_FUNCTION__), 0)));
}

CORBA::Any*
DynValue_impl::to_any ()
{
    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);

    CORBA::Long value_id;

    if (_is_null) {
      a->value_put_ref (0);
      return a;
    }

    CORBA::Boolean r = a->value_put_begin (value_id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2323, __PRETTY_FUNCTION__), 0)));

    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        CORBA::Any_var el = _elements[i]->to_any ();
        r = a->any_put (el.inout());
        ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2328, __PRETTY_FUNCTION__), 0)));
    }

    r = a->value_put_end (value_id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2332, __PRETTY_FUNCTION__), 0)));

    return a;
}

DynamicAny::FieldName
DynValue_impl::current_member_name ()
{
    if (_is_null || _index < 0)
        mico_throw (TypeMismatch());
    return CORBA::string_dup (_type->unalias()->member_name_inherited(_index));
}

CORBA::TCKind
DynValue_impl::current_member_kind ()
{
    if (_is_null || _index < 0)
        mico_throw (TypeMismatch());

    CORBA::TypeCode_var tc = _type->unalias()->member_type_inherited (_index);
    return tc->kind();
}

DynamicAny::NameValuePairSeq*
DynValue_impl::get_members ()
{
  if (_is_null) {
    mico_throw (InvalidValue());
  }

    DynamicAny::NameValuePairSeq *seq = new DynamicAny::NameValuePairSeq;
    seq->length (_elements.size());
    CORBA::TypeCode_ptr tc = _type->unalias ();
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        (*seq)[i].id = tc->member_name_inherited (i);
        CORBA::Any_var a = _elements[i]->to_any ();
        (*seq)[i].value = a.in();
    }
    return seq;
}

void
DynValue_impl::set_members (const DynamicAny::NameValuePairSeq& value)
{
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (value.length() != tc->member_count_inherited())
        mico_throw (TypeMismatch ());

    for (CORBA::ULong i = 0; i < value.length(); ++i) {
        if (strlen (value[i].id) > 0 &&
            strcmp (tc->member_name_inherited(i), value[i].id))
            mico_throw (TypeMismatch ());
        _elements[i]->from_any (value[i].value);
    }
    _index = _elements.size() > 0 ? 0 : -1;
    _is_null = 0;
}

DynamicAny::NameDynAnyPairSeq*
DynValue_impl::get_members_as_dyn_any ()
{
  if (_is_null) {
    mico_throw (InvalidValue());
  }

    DynamicAny::NameDynAnyPairSeq *seq = new DynamicAny::NameDynAnyPairSeq;
    seq->length (_elements.size());
    CORBA::TypeCode_ptr tc = _type->unalias ();
    for (CORBA::ULong i = 0; i < _elements.size(); ++i) {
        (*seq)[i].id = tc->member_name_inherited (i);
        (*seq)[i].value = _elements[i]->copy();
    }
    return seq;
}

void
DynValue_impl::set_members_as_dyn_any (
    const DynamicAny::NameDynAnyPairSeq& value)
{
    CORBA::TypeCode_ptr tc = _type->unalias ();
    if (value.length() != tc->member_count())
        mico_throw (TypeMismatch ());

    for (CORBA::ULong i = 0; i < value.length(); ++i) {
        if (strlen (value[i].id) > 0 &&
            strcmp (tc->member_name_inherited(i), value[i].id))
            mico_throw (TypeMismatch ());
        _elements[i]->assign (value[i].value.in());
    }
    _index = _elements.size() > 0 ? 0 : -1;
    _is_null = 0;
}
# 2433 "dynany_impl.cc"
DynValueBox_impl::DynValueBox_impl (CORBA::TypeCode_ptr tc)
{
    _type = CORBA::TypeCode::_duplicate (tc);
    tc = tc->unalias();
    if (tc->kind() != CORBA::tk_value_box)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());
    CORBA::TypeCode_var memtc = tc->content_type ();
    _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));
    _index = -1;
}

DynValueBox_impl::DynValueBox_impl (const CORBA::Any &a)
{
    _type = a.type();
    CORBA::TypeCode_ptr tc = _type->unalias();
    if (tc->kind() != CORBA::tk_value_box)
        mico_throw (DynamicAny::DynAnyFactory::InconsistentTypeCode ());

    CORBA::Long value_id;
    CORBA::Boolean is_ref;

    CORBA::Boolean r = a.valuebox_get_begin (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2455, __PRETTY_FUNCTION__), 0)));

    if (is_ref) {
      CORBA::TypeCode_var memtc = tc->content_type ();
      _elements.push_back(_factory()->create_dyn_any_from_type_code (memtc));

      if (!value_id) {
        _index = -1;
        _is_null = 1;
      }
      else {
        _is_null = 0;

        ((void) ((0) ? 0 : (__assert_fail ("0", "dynany_impl.cc", 2468, __PRETTY_FUNCTION__), 0)));
      }
    }

    _is_null = 0;

    CORBA::TypeCode_var memtc = tc->content_type ();
    CORBA::Any el;
    r = a.any_get (el);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2477, __PRETTY_FUNCTION__), 0)));
    el.type (memtc);

    _elements.push_back (_factory()->create_dyn_any (el));

    r = a.valuebox_get_end (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2483, __PRETTY_FUNCTION__), 0)));
}

DynValueBox_impl::~DynValueBox_impl ()
{
}

void
DynValueBox_impl::from_any (const CORBA::Any& a)
{
    CORBA::TypeCode_var tc = a.type();
    if (!_type->equaltype (tc))
        mico_throw (TypeMismatch ());

    CORBA::Long value_id;
    CORBA::Boolean is_ref;
    CORBA::Boolean r = a.valuebox_get_begin (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2500, __PRETTY_FUNCTION__), 0)));

    if (is_ref) {
      if (!value_id) {
        _is_null = 1;
        return;
      }


      ((void) ((0) ? 0 : (__assert_fail ("0", "dynany_impl.cc", 2509, __PRETTY_FUNCTION__), 0)));
    }

    _is_null = 0;

    CORBA::TypeCode_ptr tc2 = tc->unalias();
    CORBA::TypeCode_var member_tc = tc2->content_type();
    CORBA::Any el;
    r = a.any_get (el);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2518, __PRETTY_FUNCTION__), 0)));
    el.type (member_tc);
    _elements[0]->from_any (el);

    r = a.valuebox_get_end (value_id, is_ref);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2523, __PRETTY_FUNCTION__), 0)));
}

CORBA::Any*
DynValueBox_impl::to_any ()
{
    CORBA::Any *a = new CORBA::Any;

    a->set_type (_type);

    CORBA::Long value_id;

    if (_is_null) {
      a->value_put_ref (0);
      return a;
    }

    CORBA::Boolean r = a->valuebox_put_begin (value_id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2541, __PRETTY_FUNCTION__), 0)));

    CORBA::Any_var el = _elements[0]->to_any ();
    r = a->any_put (el.inout());
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2545, __PRETTY_FUNCTION__), 0)));

    r = a->valuebox_put_end (value_id);
    ((void) ((r) ? 0 : (__assert_fail ("r", "dynany_impl.cc", 2548, __PRETTY_FUNCTION__), 0)));

    return a;
}

CORBA::Any *
DynValueBox_impl::get_boxed_value ()
{
  if (_is_null) {
    mico_throw (InvalidValue());
  }

  return _elements[0]->to_any ();
}

void
DynValueBox_impl::set_boxed_value (const CORBA::Any & boxed)
{
  _elements[0]->from_any (boxed);
  _is_null = 0;
  _index = 0;
}

DynamicAny::DynAny_ptr
DynValueBox_impl::get_boxed_value_as_dyn_any ()
{
  if (_is_null) {
    mico_throw (InvalidValue());
  }

  return _elements[0]->copy ();
}

void
DynValueBox_impl::set_boxed_value_as_dyn_any (DynamicAny::DynAny_ptr boxed)
{
  _elements[0]->assign (boxed);
  _is_null = 0;
  _index = 0;
}




DynAnyFactory_impl::DynAnyFactory_impl ()
{
}

DynAnyFactory_impl::~DynAnyFactory_impl ()
{
}

DynamicAny::DynAny_ptr
DynAnyFactory_impl::create_dyn_any (const CORBA::Any& value)
{
    CORBA::TypeCode_var tc = value.type();
    switch (tc->unalias()->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:
    case CORBA::tk_char:
    case CORBA::tk_wchar:
    case CORBA::tk_boolean:
    case CORBA::tk_octet:
    case CORBA::tk_short:
    case CORBA::tk_ushort:
    case CORBA::tk_long:
    case CORBA::tk_longlong:
    case CORBA::tk_ulong:
    case CORBA::tk_ulonglong:
    case CORBA::tk_float:
    case CORBA::tk_double:
    case CORBA::tk_longdouble:
    case CORBA::tk_any:
    case CORBA::tk_TypeCode:
    case CORBA::tk_objref:
    case CORBA::tk_string:
    case CORBA::tk_wstring:
        return DynamicAny::DynBasic::_duplicate (new DynBasic_impl (value));
    case CORBA::tk_enum:
        return DynamicAny::DynEnum::_duplicate (new DynEnum_impl (value));
    case CORBA::tk_struct:
    case CORBA::tk_except:
        return DynamicAny::DynStruct::_duplicate (new DynStruct_impl (value));
    case CORBA::tk_union:
        return DynamicAny::DynUnion::_duplicate (new DynUnion_impl (value));
    case CORBA::tk_sequence:
        return DynamicAny::DynSequence::_duplicate (
            new DynSequence_impl (value));
    case CORBA::tk_array:
        return DynamicAny::DynArray::_duplicate (new DynArray_impl (value));
    case CORBA::tk_fixed:
        return DynamicAny::DynFixed::_duplicate (new DynFixed_impl (value));
    case CORBA::tk_value:
        return DynamicAny::DynValue::_duplicate (new DynValue_impl (value));
    case CORBA::tk_value_box:
        return DynamicAny::DynValueBox::_duplicate (new DynValueBox_impl (value));
    default:
        mico_throw (InconsistentTypeCode());
    }
    return 0;
}

DynamicAny::DynAny_ptr
DynAnyFactory_impl::create_dyn_any_from_type_code (CORBA::TypeCode_ptr type)
{
    switch (type->unalias()->kind()) {
    case CORBA::tk_void:
    case CORBA::tk_null:
    case CORBA::tk_char:
    case CORBA::tk_wchar:
    case CORBA::tk_boolean:
    case CORBA::tk_octet:
    case CORBA::tk_short:
    case CORBA::tk_ushort:
    case CORBA::tk_long:
    case CORBA::tk_longlong:
    case CORBA::tk_ulong:
    case CORBA::tk_ulonglong:
    case CORBA::tk_float:
    case CORBA::tk_double:
    case CORBA::tk_longdouble:
    case CORBA::tk_any:
    case CORBA::tk_TypeCode:
    case CORBA::tk_objref:
    case CORBA::tk_string:
    case CORBA::tk_wstring:
        return DynamicAny::DynBasic::_duplicate (new DynBasic_impl (type));
    case CORBA::tk_enum:
        return DynamicAny::DynEnum::_duplicate (new DynEnum_impl (type));
    case CORBA::tk_struct:
    case CORBA::tk_except:
        return DynamicAny::DynStruct::_duplicate (new DynStruct_impl (type));
    case CORBA::tk_union:
        return DynamicAny::DynUnion::_duplicate (new DynUnion_impl (type));
    case CORBA::tk_sequence:
        return DynamicAny::DynSequence::_duplicate (
            new DynSequence_impl (type));
    case CORBA::tk_array:
        return DynamicAny::DynArray::_duplicate (new DynArray_impl (type));
    case CORBA::tk_fixed:
        return DynamicAny::DynFixed::_duplicate (new DynFixed_impl (type));
    case CORBA::tk_value:
        return DynamicAny::DynValue::_duplicate (new DynValue_impl (type));
    case CORBA::tk_value_box:
      return DynamicAny::DynValueBox::_duplicate (new DynValueBox_impl (type));
    default:
        mico_throw (InconsistentTypeCode());
    }
    return 0;
}
# 34 "orb_all.cc" 2
# 1 "policy_impl.cc" 1
# 27 "policy_impl.cc"
# 1 "../include/CORBA-SMALL.h" 1
# 28 "policy_impl.cc" 2
# 1 "../include/mico/impl.h" 1
# 29 "policy_impl.cc" 2
# 1 "../include/mico/throw.h" 1
# 30 "policy_impl.cc" 2
# 1 "../include/mico/poa_impl.h" 1
# 31 "policy_impl.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 32 "policy_impl.cc" 2

MICO::Policy_impl::Policy_impl (CORBA::PolicyType _pt)
{
    pt = _pt;
}

MICO::Policy_impl::~Policy_impl ()
{

}

CORBA::PolicyType
MICO::Policy_impl::policy_type ()
{
    return pt;
}

void
MICO::Policy_impl::destroy ()
{

}





MICO::DomainManager_impl::DomainManager_impl ()
{
    _policies.length (1);
    _policies[0] = new MICO::ConstructionPolicy_impl;
}

MICO::DomainManager_impl::~DomainManager_impl ()
{
}

CORBA::Policy_ptr
MICO::DomainManager_impl::get_domain_policy (CORBA::PolicyType policy_type)
{

    for (CORBA::ULong i0 = 0; i0 < _policies.length(); ++i0) {
        if (_policies[i0]->policy_type() == policy_type)
            return CORBA::Policy::_duplicate (_policies[i0]);
    }
    mico_throw (CORBA::INV_POLICY());
    return CORBA::Policy::_nil();
}

void
MICO::DomainManager_impl::set_domain_policy (CORBA::Policy_ptr policy)
{
    CORBA::PolicyType policy_type = policy->policy_type();
    for (CORBA::ULong i0 = 0; i0 < _policies.length(); ++i0) {
        if (_policies[i0]->policy_type() == policy_type) {
            _policies[i0] = CORBA::Policy::_duplicate (policy);
            return;
        }
    }
    _policies.length (_policies.length()+1);
    _policies[_policies.length()-1] = CORBA::Policy::_duplicate (policy);
}

CORBA::DomainManager_ptr
MICO::DomainManager_impl::copy ()
{
    DomainManager_impl *d = new DomainManager_impl;
    d->_managers = _managers;

    d->_policies.length (_policies.length());
    for (CORBA::ULong i = 0; i < _policies.length(); ++i)
        d->_policies[i] = _policies[i]->copy();

    return d;
}





MICO::ConstructionPolicy_impl::ConstructionPolicy_impl ()
    : MICO::Policy_impl (CORBA::SecConstruction)
{
}

MICO::ConstructionPolicy_impl::~ConstructionPolicy_impl ()
{
}

void
MICO::ConstructionPolicy_impl::make_domain_manager (
    CORBA::InterfaceDef_ptr in,
    CORBA::Boolean constr_policy)
{
    CORBA::InterfaceDef::FullInterfaceDescription_var idef =
        in->describe_interface();

    _constr[idef->id.in()] = constr_policy;
}

CORBA::Boolean
MICO::ConstructionPolicy_impl::constr_policy (CORBA::Object_ptr object)
{
    IdConstrMap::iterator i = _constr.find (object->_repoid());
    if (i != _constr.end())
        return (*i).second;
    return 0;
}

CORBA::Policy_ptr
MICO::ConstructionPolicy_impl::copy ()
{
    MICO::ConstructionPolicy_impl *p = new MICO::ConstructionPolicy_impl;
    p->_constr = _constr;
    return p;
}





MICO::TransportPrefPolicy_impl::TransportPrefPolicy_impl (
    const ProfileTagSeq &prefs)
    : MICO::Policy_impl (MICOPolicy::TRANSPORTPREF_POLICY_TYPE)
{
    _prefs = prefs;
}

MICO::TransportPrefPolicy_impl::TransportPrefPolicy_impl ()
    : MICO::Policy_impl (MICOPolicy::TRANSPORTPREF_POLICY_TYPE)
{
}

MICO::TransportPrefPolicy_impl::~TransportPrefPolicy_impl ()
{
}

MICOPolicy::TransportPrefPolicy::ProfileTagSeq *
MICO::TransportPrefPolicy_impl::preferences()
{
    return new ProfileTagSeq (_prefs);
}

void
MICO::TransportPrefPolicy_impl::preferences (const ProfileTagSeq &prefs)
{
    _prefs = prefs;
}

MICOPolicy::TransportPrefPolicy::ProfileTagSeq *
MICO::TransportPrefPolicy_impl::preferences_nocopy()
{

    return &_prefs;
}

CORBA::Policy_ptr
MICO::TransportPrefPolicy_impl::copy ()
{
    MICO::TransportPrefPolicy_impl *p = new MICO::TransportPrefPolicy_impl;
    p->_prefs = _prefs;
    return p;
}





MICO::BidirectionalPolicy_impl::BidirectionalPolicy_impl (
    BiDirPolicy::BidirectionalPolicyValue value)
    : MICO::Policy_impl (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE)
{
    _value = value;
}

MICO::BidirectionalPolicy_impl::BidirectionalPolicy_impl ()
    : MICO::Policy_impl (BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE)
{
    _value = BiDirPolicy::NORMAL;
}

MICO::BidirectionalPolicy_impl::~BidirectionalPolicy_impl ()
{
}

BiDirPolicy::BidirectionalPolicyValue
MICO::BidirectionalPolicy_impl::value ()
{
    return _value;
}

CORBA::Policy_ptr
MICO::BidirectionalPolicy_impl::copy ()
{
    MICO::BidirectionalPolicy_impl *p = new MICO::BidirectionalPolicy_impl ();
    p->_value = _value;
    return p;
}





CORBA::Policy_ptr
CORBA::ORB::create_policy (CORBA::PolicyType type, const CORBA::Any &any)
{
  if (type == PortableServer::THREAD_POLICY_ID) {
    PortableServer::ThreadPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::ThreadPolicy_impl (type, val);
  }
  else if (type == PortableServer::LIFESPAN_POLICY_ID) {
    PortableServer::LifespanPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::LifespanPolicy_impl (type, val);
  }
  else if (type == PortableServer::ID_UNIQUENESS_POLICY_ID) {
    PortableServer::IdUniquenessPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::IdUniquenessPolicy_impl (type, val);
  }
  else if (type == PortableServer::ID_ASSIGNMENT_POLICY_ID) {
    PortableServer::IdAssignmentPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::IdAssignmentPolicy_impl (type, val);
  }
  else if (type == PortableServer::IMPLICIT_ACTIVATION_POLICY_ID) {
    PortableServer::ImplicitActivationPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::ImplicitActivationPolicy_impl (type, val);
  }
  else if (type == PortableServer::SERVANT_RETENTION_POLICY_ID) {
    PortableServer::ServantRetentionPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::ServantRetentionPolicy_impl (type, val);
  }
  else if (type == PortableServer::REQUEST_PROCESSING_POLICY_ID) {
    PortableServer::RequestProcessingPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICOPOA::RequestProcessingPolicy_impl (type, val);
  }
  else if (type == MICOPolicy::TRANSPORTPREF_POLICY_TYPE) {
    MICOPolicy::TransportPrefPolicy::ProfileTagSeq val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICO::TransportPrefPolicy_impl (val);
  }
  else if (type == BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE) {
    BiDirPolicy::BidirectionalPolicyValue val;
    if (!(any >>= val))
      mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));
    return new MICO::BidirectionalPolicy_impl (val);
  }
  mico_throw (CORBA::PolicyError (CORBA::BAD_POLICY_TYPE));

  return CORBA::Policy::_nil ();
}
# 35 "orb_all.cc" 2
# 1 "service_info.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "service_info.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "service_info.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "service_info.cc" 2
# 19 "service_info.cc"
namespace CORBA { const CORBA::UShort Security = 1; }
# 71 "service_info.cc"
struct __tc_init_SERVICE_INFO {
  __tc_init_SERVICE_INFO()
  {
  }
};

static __tc_init_SERVICE_INFO __init_SERVICE_INFO;
# 36 "orb_all.cc" 2
# 1 "ioptypes.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "ioptypes.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "ioptypes.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "ioptypes.cc" 2
# 42 "ioptypes.cc"
namespace CORBA { namespace IOP { const CORBA::ULong TransactionService = 0; } }




namespace CORBA { namespace IOP { const CORBA::ULong CodeSets = 1; } }




namespace CORBA { namespace IOP { const CORBA::ULong BI_DIR_IIOP = 5; } }
# 90 "ioptypes.cc"
namespace CORBA { namespace GIOP { const CORBA::Short KeyAddr = 0; } }




namespace CORBA { namespace GIOP { const CORBA::Short ProfileAddr = 1; } }




namespace CORBA { namespace GIOP { const CORBA::Short ReferenceAddr = 2; } }
# 128 "ioptypes.cc"
struct __tc_init_IOPTYPES {
  __tc_init_IOPTYPES()
  {
  }
};

static __tc_init_IOPTYPES __init_IOPTYPES;
# 37 "orb_all.cc" 2
# 1 "tckind.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "tckind.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "tckind.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "tckind.cc" 2





struct __tc_init_TCKIND {
  __tc_init_TCKIND()
  {
  }
};

static __tc_init_TCKIND __init_TCKIND;
# 38 "orb_all.cc" 2
# 1 "orb_excepts.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "orb_excepts.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "orb_excepts.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "orb_excepts.cc" 2
# 36 "orb_excepts.cc"
void CORBA::Bounds::_throwit() const
{


  throw *this;






}

const char *CORBA::Bounds::_repoid() const
{
  return "IDL:omg.org/CORBA/Bounds:1.0";
}

void CORBA::Bounds::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 56, __PRETTY_FUNCTION__), 0)));
}

void CORBA::Bounds::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 62, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::Bounds::_clone() const
{
  return new Bounds( *this );
}

CORBA::Bounds *CORBA::Bounds::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/Bounds:1.0" ) )
    return (Bounds *) _ex;
  return __null;
}

const CORBA::Bounds *CORBA::Bounds::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/Bounds:1.0" ) )
    return (Bounds *) _ex;
  return __null;
}
# 105 "orb_excepts.cc"
void CORBA::WrongTransaction::_throwit() const
{


  throw *this;






}

const char *CORBA::WrongTransaction::_repoid() const
{
  return "IDL:omg.org/CORBA/WrongTransaction:1.0";
}

void CORBA::WrongTransaction::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 125, __PRETTY_FUNCTION__), 0)));
}

void CORBA::WrongTransaction::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 131, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::WrongTransaction::_clone() const
{
  return new WrongTransaction( *this );
}

CORBA::WrongTransaction *CORBA::WrongTransaction::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/WrongTransaction:1.0" ) )
    return (WrongTransaction *) _ex;
  return __null;
}

const CORBA::WrongTransaction *CORBA::WrongTransaction::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/WrongTransaction:1.0" ) )
    return (WrongTransaction *) _ex;
  return __null;
}
# 174 "orb_excepts.cc"
void CORBA::ORB_InvalidName::_throwit() const
{


  throw *this;






}

const char *CORBA::ORB_InvalidName::_repoid() const
{
  return "IDL:omg.org/CORBA/ORB/InvalidName:1.0";
}

void CORBA::ORB_InvalidName::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 194, __PRETTY_FUNCTION__), 0)));
}

void CORBA::ORB_InvalidName::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 200, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::ORB_InvalidName::_clone() const
{
  return new ORB_InvalidName( *this );
}

CORBA::ORB_InvalidName *CORBA::ORB_InvalidName::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/ORB/InvalidName:1.0" ) )
    return (ORB_InvalidName *) _ex;
  return __null;
}

const CORBA::ORB_InvalidName *CORBA::ORB_InvalidName::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/ORB/InvalidName:1.0" ) )
    return (ORB_InvalidName *) _ex;
  return __null;
}
# 243 "orb_excepts.cc"
void CORBA::TypeCode_Bounds::_throwit() const
{


  throw *this;






}

const char *CORBA::TypeCode_Bounds::_repoid() const
{
  return "IDL:omg.org/CORBA/TypeCode/InvalidName:1.0";
}

void CORBA::TypeCode_Bounds::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 263, __PRETTY_FUNCTION__), 0)));
}

void CORBA::TypeCode_Bounds::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 269, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::TypeCode_Bounds::_clone() const
{
  return new TypeCode_Bounds( *this );
}

CORBA::TypeCode_Bounds *CORBA::TypeCode_Bounds::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/TypeCode/InvalidName:1.0" ) )
    return (TypeCode_Bounds *) _ex;
  return __null;
}

const CORBA::TypeCode_Bounds *CORBA::TypeCode_Bounds::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/TypeCode/InvalidName:1.0" ) )
    return (TypeCode_Bounds *) _ex;
  return __null;
}
# 312 "orb_excepts.cc"
void CORBA::TypeCode_BadKind::_throwit() const
{


  throw *this;






}

const char *CORBA::TypeCode_BadKind::_repoid() const
{
  return "IDL:omg.org/CORBA/TypeCode/BadKind:1.0";
}

void CORBA::TypeCode_BadKind::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 332, __PRETTY_FUNCTION__), 0)));
}

void CORBA::TypeCode_BadKind::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "orb_excepts.cc", 338, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::TypeCode_BadKind::_clone() const
{
  return new TypeCode_BadKind( *this );
}

CORBA::TypeCode_BadKind *CORBA::TypeCode_BadKind::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/TypeCode/BadKind:1.0" ) )
    return (TypeCode_BadKind *) _ex;
  return __null;
}

const CORBA::TypeCode_BadKind *CORBA::TypeCode_BadKind::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/TypeCode/BadKind:1.0" ) )
    return (TypeCode_BadKind *) _ex;
  return __null;
}

struct __tc_init_ORB_EXCEPTS {
  __tc_init_ORB_EXCEPTS()
  {
  }
};

static __tc_init_ORB_EXCEPTS __init_ORB_EXCEPTS;
# 39 "orb_all.cc" 2
# 1 "policy.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "policy.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "policy.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "policy.cc" 2







CORBA::Policy::~Policy()
{
}

void *CORBA::Policy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/CORBA/Policy:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

CORBA::Policy_ptr CORBA::Policy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/CORBA/Policy:1.0" )))
      return _duplicate( (CORBA::Policy_ptr) _p );
  }
  return _nil();
}

CORBA::Policy_ptr
CORBA::Policy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}






CORBA::DomainManager::~DomainManager()
{
}

void *CORBA::DomainManager::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/CORBA/DomainManager:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

CORBA::DomainManager_ptr CORBA::DomainManager::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/CORBA/DomainManager:1.0" )))
      return _duplicate( (CORBA::DomainManager_ptr) _p );
  }
  return _nil();
}

CORBA::DomainManager_ptr
CORBA::DomainManager::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace CORBA { const CORBA::ULong SecConstruction = 11; }





CORBA::ConstructionPolicy::~ConstructionPolicy()
{
}

void *CORBA::ConstructionPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/CORBA/ConstructionPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

CORBA::ConstructionPolicy_ptr CORBA::ConstructionPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/CORBA/ConstructionPolicy:1.0" )))
      return _duplicate( (CORBA::ConstructionPolicy_ptr) _p );
  }
  return _nil();
}

CORBA::ConstructionPolicy_ptr
CORBA::ConstructionPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}





namespace CORBA { const CORBA::Short BAD_POLICY = 0; }




namespace CORBA { const CORBA::Short UNSUPPORTED_POLICY = 1; }




namespace CORBA { const CORBA::Short BAD_POLICY_TYPE = 2; }




namespace CORBA { const CORBA::Short BAD_POLICY_VALUE = 3; }




namespace CORBA { const CORBA::Short UNSUPPORTED_POLICY_VALUE = 4; }
# 170 "policy.cc"
CORBA::PolicyError::PolicyError()
{
}



CORBA::PolicyError::PolicyError( CORBA::PolicyErrorCode _m0 )
{
  reason = _m0;
}

void CORBA::PolicyError::_throwit() const
{


  throw *this;






}

const char *CORBA::PolicyError::_repoid() const
{
  return "IDL:omg.org/CORBA/PolicyError:1.0";
}

void CORBA::PolicyError::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "policy.cc", 201, __PRETTY_FUNCTION__), 0)));
}

void CORBA::PolicyError::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "policy.cc", 207, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *CORBA::PolicyError::_clone() const
{
  return new PolicyError( *this );
}

CORBA::PolicyError *CORBA::PolicyError::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/PolicyError:1.0" ) )
    return (PolicyError *) _ex;
  return __null;
}

const CORBA::PolicyError *CORBA::PolicyError::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/CORBA/PolicyError:1.0" ) )
    return (PolicyError *) _ex;
  return __null;
}

struct __tc_init_POLICY {
  __tc_init_POLICY()
  {
  }
};

static __tc_init_POLICY __init_POLICY;
# 40 "orb_all.cc" 2
# 1 "poa.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "poa.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "poa.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "poa.cc" 2





namespace PortableServer { CORBA::TypeCodeConst _tc_POAList; }





namespace PortableServer { CORBA::TypeCodeConst _tc_ObjectId; }





namespace PortableServer { CORBA::TypeCodeConst _tc_ForwardRequest; }
# 56 "poa.cc"
PortableServer::ForwardRequest::ForwardRequest()
{
}



PortableServer::ForwardRequest::ForwardRequest( CORBA::Object_ptr _m0 )
{
  forward_reference = CORBA::Object::_duplicate( _m0 );
}

class _Marshaller_PortableServer_ForwardRequest : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::ForwardRequest _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_ForwardRequest::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_ForwardRequest::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_ForwardRequest::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_ForwardRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    CORBA::_stc_Object->demarshal( dc, &((_MICO_T*)v)->forward_reference._for_demarshal() ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_ForwardRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/ForwardRequest:1.0" );
  CORBA::_stc_Object->marshal( ec, &((_MICO_T*)v)->forward_reference.inout() );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_ForwardRequest::typecode()
{
  return PortableServer::_tc_ForwardRequest;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_ForwardRequest;

void operator<<=( CORBA::Any &_a, const PortableServer::ForwardRequest &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ForwardRequest, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::ForwardRequest *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::ForwardRequest &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ForwardRequest, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::ForwardRequest *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_ForwardRequest, (void *&)_e);
}

void PortableServer::ForwardRequest::_throwit() const
{


  throw *this;






}

const char *PortableServer::ForwardRequest::_repoid() const
{
  return "IDL:omg.org/PortableServer/ForwardRequest:1.0";
}

void PortableServer::ForwardRequest::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 160, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::ForwardRequest::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::ForwardRequest::_clone() const
{
  return new ForwardRequest( *this );
}

PortableServer::ForwardRequest *PortableServer::ForwardRequest::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/ForwardRequest:1.0" ) )
    return (ForwardRequest *) _ex;
  return __null;
}

const PortableServer::ForwardRequest *PortableServer::ForwardRequest::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/ForwardRequest:1.0" ) )
    return (ForwardRequest *) _ex;
  return __null;
}


namespace PortableServer { const CORBA::ULong THREAD_POLICY_ID = 16; }




namespace PortableServer { const CORBA::ULong LIFESPAN_POLICY_ID = 17; }




namespace PortableServer { const CORBA::ULong ID_UNIQUENESS_POLICY_ID = 18; }




namespace PortableServer { const CORBA::ULong ID_ASSIGNMENT_POLICY_ID = 19; }




namespace PortableServer { const CORBA::ULong IMPLICIT_ACTIVATION_POLICY_ID = 20; }




namespace PortableServer { const CORBA::ULong SERVANT_RETENTION_POLICY_ID = 21; }




namespace PortableServer { const CORBA::ULong REQUEST_PROCESSING_POLICY_ID = 22; }




namespace PortableServer { CORBA::TypeCodeConst _tc_ThreadPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::ThreadPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ThreadPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::ThreadPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ThreadPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_ThreadPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::ThreadPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_ThreadPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_ThreadPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_ThreadPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_ThreadPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_ThreadPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_ThreadPolicyValue::typecode()
{
  return PortableServer::_tc_ThreadPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_ThreadPolicyValue;



PortableServer::ThreadPolicy::~ThreadPolicy()
{
}

void *PortableServer::ThreadPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ThreadPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::ThreadPolicy_ptr PortableServer::ThreadPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ThreadPolicy:1.0" )))
      return _duplicate( (PortableServer::ThreadPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::ThreadPolicy_ptr
PortableServer::ThreadPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_LifespanPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::LifespanPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_LifespanPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::LifespanPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_LifespanPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_LifespanPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::LifespanPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_LifespanPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_LifespanPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_LifespanPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_LifespanPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_LifespanPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_LifespanPolicyValue::typecode()
{
  return PortableServer::_tc_LifespanPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_LifespanPolicyValue;



PortableServer::LifespanPolicy::~LifespanPolicy()
{
}

void *PortableServer::LifespanPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/LifespanPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::LifespanPolicy_ptr PortableServer::LifespanPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/LifespanPolicy:1.0" )))
      return _duplicate( (PortableServer::LifespanPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::LifespanPolicy_ptr
PortableServer::LifespanPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_IdUniquenessPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::IdUniquenessPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_IdUniquenessPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::IdUniquenessPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_IdUniquenessPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_IdUniquenessPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::IdUniquenessPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_IdUniquenessPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_IdUniquenessPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_IdUniquenessPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_IdUniquenessPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_IdUniquenessPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_IdUniquenessPolicyValue::typecode()
{
  return PortableServer::_tc_IdUniquenessPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_IdUniquenessPolicyValue;



PortableServer::IdUniquenessPolicy::~IdUniquenessPolicy()
{
}

void *PortableServer::IdUniquenessPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::IdUniquenessPolicy_ptr PortableServer::IdUniquenessPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0" )))
      return _duplicate( (PortableServer::IdUniquenessPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::IdUniquenessPolicy_ptr
PortableServer::IdUniquenessPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_IdAssignmentPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::IdAssignmentPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_IdAssignmentPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::IdAssignmentPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_IdAssignmentPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_IdAssignmentPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::IdAssignmentPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_IdAssignmentPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_IdAssignmentPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_IdAssignmentPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_IdAssignmentPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_IdAssignmentPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_IdAssignmentPolicyValue::typecode()
{
  return PortableServer::_tc_IdAssignmentPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_IdAssignmentPolicyValue;



PortableServer::IdAssignmentPolicy::~IdAssignmentPolicy()
{
}

void *PortableServer::IdAssignmentPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::IdAssignmentPolicy_ptr PortableServer::IdAssignmentPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0" )))
      return _duplicate( (PortableServer::IdAssignmentPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::IdAssignmentPolicy_ptr
PortableServer::IdAssignmentPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_ImplicitActivationPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::ImplicitActivationPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ImplicitActivationPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::ImplicitActivationPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ImplicitActivationPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_ImplicitActivationPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::ImplicitActivationPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_ImplicitActivationPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_ImplicitActivationPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_ImplicitActivationPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_ImplicitActivationPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_ImplicitActivationPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_ImplicitActivationPolicyValue::typecode()
{
  return PortableServer::_tc_ImplicitActivationPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_ImplicitActivationPolicyValue;



PortableServer::ImplicitActivationPolicy::~ImplicitActivationPolicy()
{
}

void *PortableServer::ImplicitActivationPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::ImplicitActivationPolicy_ptr PortableServer::ImplicitActivationPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0" )))
      return _duplicate( (PortableServer::ImplicitActivationPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::ImplicitActivationPolicy_ptr
PortableServer::ImplicitActivationPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_ServantRetentionPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::ServantRetentionPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ServantRetentionPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::ServantRetentionPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_ServantRetentionPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_ServantRetentionPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::ServantRetentionPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_ServantRetentionPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_ServantRetentionPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_ServantRetentionPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_ServantRetentionPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_ServantRetentionPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_ServantRetentionPolicyValue::typecode()
{
  return PortableServer::_tc_ServantRetentionPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_ServantRetentionPolicyValue;



PortableServer::ServantRetentionPolicy::~ServantRetentionPolicy()
{
}

void *PortableServer::ServantRetentionPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::ServantRetentionPolicy_ptr PortableServer::ServantRetentionPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0" )))
      return _duplicate( (PortableServer::ServantRetentionPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::ServantRetentionPolicy_ptr
PortableServer::ServantRetentionPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst _tc_RequestProcessingPolicyValue; }




void operator<<=( CORBA::Any &_a, const PortableServer::RequestProcessingPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_RequestProcessingPolicyValue, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::RequestProcessingPolicyValue &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_RequestProcessingPolicyValue, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_RequestProcessingPolicyValue : public CORBA::StaticTypeInfo {
    typedef PortableServer::RequestProcessingPolicyValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_RequestProcessingPolicyValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_RequestProcessingPolicyValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_RequestProcessingPolicyValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_RequestProcessingPolicyValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_RequestProcessingPolicyValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_RequestProcessingPolicyValue::typecode()
{
  return PortableServer::_tc_RequestProcessingPolicyValue;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_RequestProcessingPolicyValue;



PortableServer::RequestProcessingPolicy::~RequestProcessingPolicy()
{
}

void *PortableServer::RequestProcessingPolicy::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Policy _VCHACK__CORBA__Policy;
    if ((_p = _VCHACK__CORBA__Policy::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::RequestProcessingPolicy_ptr PortableServer::RequestProcessingPolicy::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0" )))
      return _duplicate( (PortableServer::RequestProcessingPolicy_ptr) _p );
  }
  return _nil();
}

PortableServer::RequestProcessingPolicy_ptr
PortableServer::RequestProcessingPolicy::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst POAManager::_tc_AdapterInactive; }
# 962 "poa.cc"
class _Marshaller_PortableServer_POAManager_AdapterInactive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POAManager::AdapterInactive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POAManager_AdapterInactive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POAManager_AdapterInactive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POAManager_AdapterInactive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POAManager_AdapterInactive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POAManager_AdapterInactive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POAManager_AdapterInactive::typecode()
{
  return PortableServer::POAManager::_tc_AdapterInactive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POAManager_AdapterInactive;

void operator<<=( CORBA::Any &_a, const PortableServer::POAManager::AdapterInactive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POAManager_AdapterInactive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POAManager::AdapterInactive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POAManager::AdapterInactive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POAManager_AdapterInactive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POAManager::AdapterInactive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POAManager_AdapterInactive, (void *&)_e);
}

void PortableServer::POAManager::AdapterInactive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POAManager::AdapterInactive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0";
}

void PortableServer::POAManager::AdapterInactive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 1053, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POAManager::AdapterInactive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POAManager::AdapterInactive::_clone() const
{
  return new AdapterInactive( *this );
}

PortableServer::POAManager::AdapterInactive *PortableServer::POAManager::AdapterInactive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0" ) )
    return (AdapterInactive *) _ex;
  return __null;
}

const PortableServer::POAManager::AdapterInactive *PortableServer::POAManager::AdapterInactive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POAManager/AdapterInactive:1.0" ) )
    return (AdapterInactive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POAManager::_tc_State; }




void operator<<=( CORBA::Any &_a, const PortableServer::POAManager::State &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POAManager_State, &_e);
  _a.from_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POAManager::State &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POAManager_State, &_e);
  return _a.to_static_any (_sa);
}

class _Marshaller_PortableServer_POAManager_State : public CORBA::StaticTypeInfo {
    typedef PortableServer::POAManager::State _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POAManager_State::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POAManager_State::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POAManager_State::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POAManager_State::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong ul;
  if( !dc.enumeration( ul ) )
    return 0;
  *(_MICO_T*) v = (_MICO_T) ul;
  return 1;
}

void _Marshaller_PortableServer_POAManager_State::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POAManager_State::typecode()
{
  return PortableServer::POAManager::_tc_State;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POAManager_State;



PortableServer::POAManager::~POAManager()
{
}

void *PortableServer::POAManager::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/POAManager:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

PortableServer::POAManager_ptr PortableServer::POAManager::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/POAManager:1.0" )))
      return _duplicate( (PortableServer::POAManager_ptr) _p );
  }
  return _nil();
}

PortableServer::POAManager_ptr
PortableServer::POAManager::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}




PortableServer::AdapterActivator::~AdapterActivator()
{
}

void *PortableServer::AdapterActivator::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/AdapterActivator:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

PortableServer::AdapterActivator_ptr PortableServer::AdapterActivator::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/AdapterActivator:1.0" )))
      return _duplicate( (PortableServer::AdapterActivator_ptr) _p );
  }
  return _nil();
}

PortableServer::AdapterActivator_ptr
PortableServer::AdapterActivator::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}




PortableServer::ServantManager::~ServantManager()
{
}

void *PortableServer::ServantManager::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ServantManager:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

PortableServer::ServantManager_ptr PortableServer::ServantManager::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ServantManager:1.0" )))
      return _duplicate( (PortableServer::ServantManager_ptr) _p );
  }
  return _nil();
}

PortableServer::ServantManager_ptr
PortableServer::ServantManager::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}




PortableServer::ServantActivator::~ServantActivator()
{
}

void *PortableServer::ServantActivator::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ServantActivator:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef PortableServer::ServantManager _VCHACK__PortableServer__ServantManager;
    if ((_p = _VCHACK__PortableServer__ServantManager::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::ServantActivator_ptr PortableServer::ServantActivator::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ServantActivator:1.0" )))
      return _duplicate( (PortableServer::ServantActivator_ptr) _p );
  }
  return _nil();
}

PortableServer::ServantActivator_ptr
PortableServer::ServantActivator::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}




PortableServer::ServantLocator::~ServantLocator()
{
}

void *PortableServer::ServantLocator::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/ServantLocator:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef PortableServer::ServantManager _VCHACK__PortableServer__ServantManager;
    if ((_p = _VCHACK__PortableServer__ServantManager::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::ServantLocator_ptr PortableServer::ServantLocator::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/ServantLocator:1.0" )))
      return _duplicate( (PortableServer::ServantLocator_ptr) _p );
  }
  return _nil();
}

PortableServer::ServantLocator_ptr
PortableServer::ServantLocator::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst POA::_tc_AdapterAlreadyExists; }
# 1334 "poa.cc"
class _Marshaller_PortableServer_POA_AdapterAlreadyExists : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::AdapterAlreadyExists _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_AdapterAlreadyExists::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_AdapterAlreadyExists::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_AdapterAlreadyExists::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_AdapterAlreadyExists::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_AdapterAlreadyExists::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_AdapterAlreadyExists::typecode()
{
  return PortableServer::POA::_tc_AdapterAlreadyExists;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterAlreadyExists;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::AdapterAlreadyExists &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterAlreadyExists, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::AdapterAlreadyExists *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::AdapterAlreadyExists &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterAlreadyExists, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::AdapterAlreadyExists *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_AdapterAlreadyExists, (void *&)_e);
}

void PortableServer::POA::AdapterAlreadyExists::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::AdapterAlreadyExists::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0";
}

void PortableServer::POA::AdapterAlreadyExists::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 1425, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::AdapterAlreadyExists::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::AdapterAlreadyExists::_clone() const
{
  return new AdapterAlreadyExists( *this );
}

PortableServer::POA::AdapterAlreadyExists *PortableServer::POA::AdapterAlreadyExists::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0" ) )
    return (AdapterAlreadyExists *) _ex;
  return __null;
}

const PortableServer::POA::AdapterAlreadyExists *PortableServer::POA::AdapterAlreadyExists::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterAlreadyExists:1.0" ) )
    return (AdapterAlreadyExists *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_AdapterInactive; }
# 1478 "poa.cc"
class _Marshaller_PortableServer_POA_AdapterInactive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::AdapterInactive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_AdapterInactive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_AdapterInactive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_AdapterInactive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_AdapterInactive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_AdapterInactive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/AdapterInactive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_AdapterInactive::typecode()
{
  return PortableServer::POA::_tc_AdapterInactive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterInactive;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::AdapterInactive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterInactive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::AdapterInactive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::AdapterInactive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterInactive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::AdapterInactive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_AdapterInactive, (void *&)_e);
}

void PortableServer::POA::AdapterInactive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::AdapterInactive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/AdapterInactive:1.0";
}

void PortableServer::POA::AdapterInactive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 1569, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::AdapterInactive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::AdapterInactive::_clone() const
{
  return new AdapterInactive( *this );
}

PortableServer::POA::AdapterInactive *PortableServer::POA::AdapterInactive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterInactive:1.0" ) )
    return (AdapterInactive *) _ex;
  return __null;
}

const PortableServer::POA::AdapterInactive *PortableServer::POA::AdapterInactive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterInactive:1.0" ) )
    return (AdapterInactive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_AdapterNonExistent; }
# 1622 "poa.cc"
class _Marshaller_PortableServer_POA_AdapterNonExistent : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::AdapterNonExistent _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_AdapterNonExistent::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_AdapterNonExistent::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_AdapterNonExistent::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_AdapterNonExistent::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_AdapterNonExistent::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_AdapterNonExistent::typecode()
{
  return PortableServer::POA::_tc_AdapterNonExistent;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_AdapterNonExistent;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::AdapterNonExistent &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterNonExistent, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::AdapterNonExistent *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::AdapterNonExistent &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_AdapterNonExistent, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::AdapterNonExistent *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_AdapterNonExistent, (void *&)_e);
}

void PortableServer::POA::AdapterNonExistent::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::AdapterNonExistent::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0";
}

void PortableServer::POA::AdapterNonExistent::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 1713, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::AdapterNonExistent::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::AdapterNonExistent::_clone() const
{
  return new AdapterNonExistent( *this );
}

PortableServer::POA::AdapterNonExistent *PortableServer::POA::AdapterNonExistent::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0" ) )
    return (AdapterNonExistent *) _ex;
  return __null;
}

const PortableServer::POA::AdapterNonExistent *PortableServer::POA::AdapterNonExistent::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/AdapterNonExistent:1.0" ) )
    return (AdapterNonExistent *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_InvalidPolicy; }
# 1769 "poa.cc"
PortableServer::POA::InvalidPolicy::InvalidPolicy()
{
}



PortableServer::POA::InvalidPolicy::InvalidPolicy( CORBA::UShort _m0 )
{
  index = _m0;
}

class _Marshaller_PortableServer_POA_InvalidPolicy : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::InvalidPolicy _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_InvalidPolicy::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_InvalidPolicy::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_InvalidPolicy::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_InvalidPolicy::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    CORBA::_stc_ushort->demarshal( dc, &((_MICO_T*)v)->index ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_InvalidPolicy::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0" );
  CORBA::_stc_ushort->marshal( ec, &((_MICO_T*)v)->index );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_InvalidPolicy::typecode()
{
  return PortableServer::POA::_tc_InvalidPolicy;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_InvalidPolicy;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::InvalidPolicy &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_InvalidPolicy, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::InvalidPolicy *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::InvalidPolicy &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_InvalidPolicy, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::InvalidPolicy *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_InvalidPolicy, (void *&)_e);
}

void PortableServer::POA::InvalidPolicy::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::InvalidPolicy::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0";
}

void PortableServer::POA::InvalidPolicy::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 1873, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::InvalidPolicy::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::InvalidPolicy::_clone() const
{
  return new InvalidPolicy( *this );
}

PortableServer::POA::InvalidPolicy *PortableServer::POA::InvalidPolicy::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0" ) )
    return (InvalidPolicy *) _ex;
  return __null;
}

const PortableServer::POA::InvalidPolicy *PortableServer::POA::InvalidPolicy::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/InvalidPolicy:1.0" ) )
    return (InvalidPolicy *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_NoServant; }
# 1926 "poa.cc"
class _Marshaller_PortableServer_POA_NoServant : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::NoServant _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_NoServant::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_NoServant::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_NoServant::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_NoServant::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_NoServant::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/NoServant:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_NoServant::typecode()
{
  return PortableServer::POA::_tc_NoServant;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_NoServant;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::NoServant &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_NoServant, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::NoServant *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::NoServant &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_NoServant, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::NoServant *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_NoServant, (void *&)_e);
}

void PortableServer::POA::NoServant::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::NoServant::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/NoServant:1.0";
}

void PortableServer::POA::NoServant::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2017, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::NoServant::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::NoServant::_clone() const
{
  return new NoServant( *this );
}

PortableServer::POA::NoServant *PortableServer::POA::NoServant::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/NoServant:1.0" ) )
    return (NoServant *) _ex;
  return __null;
}

const PortableServer::POA::NoServant *PortableServer::POA::NoServant::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/NoServant:1.0" ) )
    return (NoServant *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_ObjectAlreadyActive; }
# 2070 "poa.cc"
class _Marshaller_PortableServer_POA_ObjectAlreadyActive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::ObjectAlreadyActive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_ObjectAlreadyActive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_ObjectAlreadyActive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_ObjectAlreadyActive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_ObjectAlreadyActive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_ObjectAlreadyActive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_ObjectAlreadyActive::typecode()
{
  return PortableServer::POA::_tc_ObjectAlreadyActive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ObjectAlreadyActive;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::ObjectAlreadyActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ObjectAlreadyActive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::ObjectAlreadyActive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::ObjectAlreadyActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ObjectAlreadyActive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::ObjectAlreadyActive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_ObjectAlreadyActive, (void *&)_e);
}

void PortableServer::POA::ObjectAlreadyActive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::ObjectAlreadyActive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0";
}

void PortableServer::POA::ObjectAlreadyActive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2161, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::ObjectAlreadyActive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::ObjectAlreadyActive::_clone() const
{
  return new ObjectAlreadyActive( *this );
}

PortableServer::POA::ObjectAlreadyActive *PortableServer::POA::ObjectAlreadyActive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0" ) )
    return (ObjectAlreadyActive *) _ex;
  return __null;
}

const PortableServer::POA::ObjectAlreadyActive *PortableServer::POA::ObjectAlreadyActive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ObjectAlreadyActive:1.0" ) )
    return (ObjectAlreadyActive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_ObjectNotActive; }
# 2214 "poa.cc"
class _Marshaller_PortableServer_POA_ObjectNotActive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::ObjectNotActive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_ObjectNotActive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_ObjectNotActive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_ObjectNotActive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_ObjectNotActive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_ObjectNotActive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_ObjectNotActive::typecode()
{
  return PortableServer::POA::_tc_ObjectNotActive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ObjectNotActive;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::ObjectNotActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ObjectNotActive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::ObjectNotActive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::ObjectNotActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ObjectNotActive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::ObjectNotActive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_ObjectNotActive, (void *&)_e);
}

void PortableServer::POA::ObjectNotActive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::ObjectNotActive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0";
}

void PortableServer::POA::ObjectNotActive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2305, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::ObjectNotActive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::ObjectNotActive::_clone() const
{
  return new ObjectNotActive( *this );
}

PortableServer::POA::ObjectNotActive *PortableServer::POA::ObjectNotActive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0" ) )
    return (ObjectNotActive *) _ex;
  return __null;
}

const PortableServer::POA::ObjectNotActive *PortableServer::POA::ObjectNotActive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ObjectNotActive:1.0" ) )
    return (ObjectNotActive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_ServantAlreadyActive; }
# 2358 "poa.cc"
class _Marshaller_PortableServer_POA_ServantAlreadyActive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::ServantAlreadyActive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_ServantAlreadyActive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_ServantAlreadyActive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_ServantAlreadyActive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_ServantAlreadyActive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_ServantAlreadyActive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_ServantAlreadyActive::typecode()
{
  return PortableServer::POA::_tc_ServantAlreadyActive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ServantAlreadyActive;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::ServantAlreadyActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ServantAlreadyActive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::ServantAlreadyActive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::ServantAlreadyActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ServantAlreadyActive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::ServantAlreadyActive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_ServantAlreadyActive, (void *&)_e);
}

void PortableServer::POA::ServantAlreadyActive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::ServantAlreadyActive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0";
}

void PortableServer::POA::ServantAlreadyActive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2449, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::ServantAlreadyActive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::ServantAlreadyActive::_clone() const
{
  return new ServantAlreadyActive( *this );
}

PortableServer::POA::ServantAlreadyActive *PortableServer::POA::ServantAlreadyActive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0" ) )
    return (ServantAlreadyActive *) _ex;
  return __null;
}

const PortableServer::POA::ServantAlreadyActive *PortableServer::POA::ServantAlreadyActive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ServantAlreadyActive:1.0" ) )
    return (ServantAlreadyActive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_ServantNotActive; }
# 2502 "poa.cc"
class _Marshaller_PortableServer_POA_ServantNotActive : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::ServantNotActive _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_ServantNotActive::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_ServantNotActive::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_ServantNotActive::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_ServantNotActive::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_ServantNotActive::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/ServantNotActive:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_ServantNotActive::typecode()
{
  return PortableServer::POA::_tc_ServantNotActive;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_ServantNotActive;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::ServantNotActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ServantNotActive, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::ServantNotActive *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::ServantNotActive &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_ServantNotActive, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::ServantNotActive *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_ServantNotActive, (void *&)_e);
}

void PortableServer::POA::ServantNotActive::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::ServantNotActive::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/ServantNotActive:1.0";
}

void PortableServer::POA::ServantNotActive::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2593, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::ServantNotActive::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::ServantNotActive::_clone() const
{
  return new ServantNotActive( *this );
}

PortableServer::POA::ServantNotActive *PortableServer::POA::ServantNotActive::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ServantNotActive:1.0" ) )
    return (ServantNotActive *) _ex;
  return __null;
}

const PortableServer::POA::ServantNotActive *PortableServer::POA::ServantNotActive::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/ServantNotActive:1.0" ) )
    return (ServantNotActive *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_WrongAdapter; }
# 2646 "poa.cc"
class _Marshaller_PortableServer_POA_WrongAdapter : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::WrongAdapter _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_WrongAdapter::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_WrongAdapter::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_WrongAdapter::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_WrongAdapter::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_WrongAdapter::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/WrongAdapter:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_WrongAdapter::typecode()
{
  return PortableServer::POA::_tc_WrongAdapter;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_WrongAdapter;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::WrongAdapter &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_WrongAdapter, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::WrongAdapter *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::WrongAdapter &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_WrongAdapter, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::WrongAdapter *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_WrongAdapter, (void *&)_e);
}

void PortableServer::POA::WrongAdapter::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::WrongAdapter::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/WrongAdapter:1.0";
}

void PortableServer::POA::WrongAdapter::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2737, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::WrongAdapter::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::WrongAdapter::_clone() const
{
  return new WrongAdapter( *this );
}

PortableServer::POA::WrongAdapter *PortableServer::POA::WrongAdapter::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/WrongAdapter:1.0" ) )
    return (WrongAdapter *) _ex;
  return __null;
}

const PortableServer::POA::WrongAdapter *PortableServer::POA::WrongAdapter::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/WrongAdapter:1.0" ) )
    return (WrongAdapter *) _ex;
  return __null;
}


namespace PortableServer { CORBA::TypeCodeConst POA::_tc_WrongPolicy; }
# 2790 "poa.cc"
class _Marshaller_PortableServer_POA_WrongPolicy : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::POA::WrongPolicy _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_POA_WrongPolicy::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_POA_WrongPolicy::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_POA_WrongPolicy::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_POA_WrongPolicy::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_POA_WrongPolicy::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/POA/WrongPolicy:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_POA_WrongPolicy::typecode()
{
  return PortableServer::POA::_tc_WrongPolicy;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_POA_WrongPolicy;

void operator<<=( CORBA::Any &_a, const PortableServer::POA::WrongPolicy &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_WrongPolicy, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::POA::WrongPolicy *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::POA::WrongPolicy &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_POA_WrongPolicy, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::POA::WrongPolicy *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_POA_WrongPolicy, (void *&)_e);
}

void PortableServer::POA::WrongPolicy::_throwit() const
{


  throw *this;






}

const char *PortableServer::POA::WrongPolicy::_repoid() const
{
  return "IDL:omg.org/PortableServer/POA/WrongPolicy:1.0";
}

void PortableServer::POA::WrongPolicy::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 2881, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::POA::WrongPolicy::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::POA::WrongPolicy::_clone() const
{
  return new WrongPolicy( *this );
}

PortableServer::POA::WrongPolicy *PortableServer::POA::WrongPolicy::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/WrongPolicy:1.0" ) )
    return (WrongPolicy *) _ex;
  return __null;
}

const PortableServer::POA::WrongPolicy *PortableServer::POA::WrongPolicy::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/POA/WrongPolicy:1.0" ) )
    return (WrongPolicy *) _ex;
  return __null;
}



PortableServer::POA::~POA()
{
}

void *PortableServer::POA::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/POA:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

PortableServer::POA_ptr PortableServer::POA::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/POA:1.0" )))
      return _duplicate( (PortableServer::POA_ptr) _p );
  }
  return _nil();
}

PortableServer::POA_ptr
PortableServer::POA::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}



namespace PortableServer { CORBA::TypeCodeConst Current::_tc_NoContext; }
# 2964 "poa.cc"
class _Marshaller_PortableServer_Current_NoContext : public CORBA::StaticTypeInfo {
    typedef ::PortableServer::Current::NoContext _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller_PortableServer_Current_NoContext::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_PortableServer_Current_NoContext::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_PortableServer_Current_NoContext::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_PortableServer_Current_NoContext::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_PortableServer_Current_NoContext::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/PortableServer/Current/NoContext:1.0" );
  ec.except_end();
}

CORBA::TypeCode_ptr _Marshaller_PortableServer_Current_NoContext::typecode()
{
  return PortableServer::Current::_tc_NoContext;
}

CORBA::StaticTypeInfo *_marshaller_PortableServer_Current_NoContext;

void operator<<=( CORBA::Any &_a, const PortableServer::Current::NoContext &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_Current_NoContext, &_e);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, PortableServer::Current::NoContext *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, PortableServer::Current::NoContext &_e )
{
  CORBA::StaticAny _sa (_marshaller_PortableServer_Current_NoContext, &_e);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const PortableServer::Current::NoContext *&_e )
{
  return _a.to_static_any (_marshaller_PortableServer_Current_NoContext, (void *&)_e);
}

void PortableServer::Current::NoContext::_throwit() const
{


  throw *this;






}

const char *PortableServer::Current::NoContext::_repoid() const
{
  return "IDL:omg.org/PortableServer/Current/NoContext:1.0";
}

void PortableServer::Current::NoContext::_encode( CORBA::DataEncoder &_en ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 3055, __PRETTY_FUNCTION__), 0)));
}

void PortableServer::Current::NoContext::_encode_any( CORBA::Any &_a ) const
{
  _a <<= *this;
}

CORBA::Exception *PortableServer::Current::NoContext::_clone() const
{
  return new NoContext( *this );
}

PortableServer::Current::NoContext *PortableServer::Current::NoContext::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/Current/NoContext:1.0" ) )
    return (NoContext *) _ex;
  return __null;
}

const PortableServer::Current::NoContext *PortableServer::Current::NoContext::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/PortableServer/Current/NoContext:1.0" ) )
    return (NoContext *) _ex;
  return __null;
}



PortableServer::Current::~Current()
{
}

void *PortableServer::Current::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/PortableServer/Current:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef CORBA::Current _VCHACK__CORBA__Current;
    if ((_p = _VCHACK__CORBA__Current::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

PortableServer::Current_ptr PortableServer::Current::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/PortableServer/Current:1.0" )))
      return _duplicate( (PortableServer::Current_ptr) _p );
  }
  return _nil();
}

PortableServer::Current_ptr
PortableServer::Current::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}


class _Marshaller__seq_PortableServer_POA : public CORBA::StaticTypeInfo {
    typedef IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> _MICO_T;
    static CORBA::TypeCode_ptr _tc;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
    CORBA::TypeCode_ptr typecode ();
};


CORBA::StaticValueType _Marshaller__seq_PortableServer_POA::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller__seq_PortableServer_POA::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller__seq_PortableServer_POA::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller__seq_PortableServer_POA::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 3148, __PRETTY_FUNCTION__), 0)));
  return 0;
}

void _Marshaller__seq_PortableServer_POA::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa.cc", 3154, __PRETTY_FUNCTION__), 0)));
}

CORBA::TypeCode_ptr _Marshaller__seq_PortableServer_POA::typecode()
{
  if (!_tc)
    _tc = (new CORBA::TypeCode (
    "010000001300000044000000010000000e00000034000000010000002300"
    "000049444c3a6f6d672e6f72672f506f727461626c655365727665722f50"
    "4f413a312e30000004000000504f410000000000"))->mk_constant();
  return _tc;
}

CORBA::TypeCode_ptr _Marshaller__seq_PortableServer_POA::_tc = 0;
CORBA::StaticTypeInfo *_marshaller__seq_PortableServer_POA;

void operator<<=( CORBA::Any &_a, const IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> &_s )
{
  CORBA::StaticAny _sa (_marshaller__seq_PortableServer_POA, &_s);
  _a.from_static_any (_sa);
}

void operator<<=( CORBA::Any &_a, IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> *_s )
{
  _a <<= *_s;
  delete _s;
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> &_s )
{
  CORBA::StaticAny _sa (_marshaller__seq_PortableServer_POA, &_s);
  return _a.to_static_any (_sa);
}

CORBA::Boolean operator>>=( const CORBA::Any &_a, const IfaceSequenceTmpl<PortableServer::POA_var,PortableServer::POA_ptr> *&_s )
{
  return _a.to_static_any (_marshaller__seq_PortableServer_POA, (void *&)_s);
}


struct __tc_init_POA {
  __tc_init_POA()
  {
    PortableServer::_tc_POAList =
    "010000001500000088000000010000002700000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f414c6973743a312e300000"
    "08000000504f414c697374001300000044000000010000000e0000003400"
    "0000010000002300000049444c3a6f6d672e6f72672f506f727461626c65"
    "5365727665722f504f413a312e30000004000000504f410000000000";
    PortableServer::_tc_ObjectId =
    "010000001500000054000000010000002800000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f4f626a65637449643a312e3000"
    "090000004f626a656374496400000000130000000c000000010000000a00"
    "000000000000";
    PortableServer::_tc_ForwardRequest =
    "0100000016000000a3000000010000002e00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f466f7277617264526571756573"
    "743a312e300000000f000000466f72776172645265717565737400000100"
    "000012000000666f72776172645f7265666572656e63650000000e000000"
    "33000000010000001d00000049444c3a6f6d672e6f72672f434f5242412f"
    "4f626a6563743a312e3000000000070000004f626a65637400";
    _marshaller_PortableServer_ForwardRequest = new _Marshaller_PortableServer_ForwardRequest;
    PortableServer::_tc_ThreadPolicyValue =
    "010000001100000084000000010000003100000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f546872656164506f6c69637956"
    "616c75653a312e300000000012000000546872656164506f6c6963795661"
    "6c7565000000020000000f0000004f52425f4354524c5f4d4f44454c0000"
    "1400000053494e474c455f5448524541445f4d4f44454c00";
    _marshaller_PortableServer_ThreadPolicyValue = new _Marshaller_PortableServer_ThreadPolicyValue;
    PortableServer::_tc_LifespanPolicyValue =
    "010000001100000077000000010000003300000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f4c6966657370616e506f6c6963"
    "7956616c75653a312e300000140000004c6966657370616e506f6c696379"
    "56616c756500020000000a0000005452414e5349454e540000000b000000"
    "50455253495354454e5400";
    _marshaller_PortableServer_LifespanPolicyValue = new _Marshaller_PortableServer_LifespanPolicyValue;
    PortableServer::_tc_IdUniquenessPolicyValue =
    "010000001100000080000000010000003700000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f4964556e697175656e65737350"
    "6f6c69637956616c75653a312e300000180000004964556e697175656e65"
    "7373506f6c69637956616c756500020000000a000000554e495155455f49"
    "440000000c0000004d554c5449504c455f494400";
    _marshaller_PortableServer_IdUniquenessPolicyValue = new _Marshaller_PortableServer_IdUniquenessPolicyValue;
    PortableServer::_tc_IdAssignmentPolicyValue =
    "01000000110000007a000000010000003700000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f496441737369676e6d656e7450"
    "6f6c69637956616c75653a312e30000018000000496441737369676e6d65"
    "6e74506f6c69637956616c7565000200000008000000555345525f494400"
    "0a00000053595354454d5f494400";
    _marshaller_PortableServer_IdAssignmentPolicyValue = new _Marshaller_PortableServer_IdAssignmentPolicyValue;
    PortableServer::_tc_ImplicitActivationPolicyValue =
    "0100000011000000a3000000010000003d00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f496d706c696369744163746976"
    "6174696f6e506f6c69637956616c75653a312e30000000001e000000496d"
    "706c6963697441637469766174696f6e506f6c69637956616c7565000000"
    "0200000014000000494d504c494349545f41435449564154494f4e001700"
    "00004e4f5f494d504c494349545f41435449564154494f4e00";
    _marshaller_PortableServer_ImplicitActivationPolicyValue = new _Marshaller_PortableServer_ImplicitActivationPolicyValue;
    PortableServer::_tc_ServantRetentionPolicyValue =
    "010000001100000083000000010000003b00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f53657276616e74526574656e74"
    "696f6e506f6c69637956616c75653a312e3000001c00000053657276616e"
    "74526574656e74696f6e506f6c69637956616c7565000200000007000000"
    "52455441494e00000b0000004e4f4e5f52455441494e00";
    _marshaller_PortableServer_ServantRetentionPolicyValue = new _Marshaller_PortableServer_ServantRetentionPolicyValue;
    PortableServer::_tc_RequestProcessingPolicyValue =
    "0100000011000000bc000000010000003c00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f5265717565737450726f636573"
    "73696e67506f6c69637956616c75653a312e30001d000000526571756573"
    "7450726f63657373696e67506f6c69637956616c75650000000003000000"
    "1b0000005553455f4143544956455f4f424a4543545f4d41505f4f4e4c59"
    "0000140000005553455f44454641554c545f53455256414e540014000000"
    "5553455f53455256414e545f4d414e4147455200";
    _marshaller_PortableServer_RequestProcessingPolicyValue = new _Marshaller_PortableServer_RequestProcessingPolicyValue;
    PortableServer::POAManager::_tc_AdapterInactive =
    "01000000160000005c000000010000003a00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f414d616e616765722f4164"
    "6170746572496e6163746976653a312e3000000010000000416461707465"
    "72496e6163746976650000000000";
    _marshaller_PortableServer_POAManager_AdapterInactive = new _Marshaller_PortableServer_POAManager_AdapterInactive;
    PortableServer::POAManager::_tc_State =
    "01000000110000007d000000010000003000000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f414d616e616765722f5374"
    "6174653a312e30000600000053746174650000000400000008000000484f"
    "4c44494e47000700000041435449564500000b0000004449534341524449"
    "4e47000009000000494e41435449564500";
    _marshaller_PortableServer_POAManager_State = new _Marshaller_PortableServer_POAManager_State;
    PortableServer::POA::_tc_AdapterAlreadyExists =
    "010000001600000060000000010000003800000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f41646170746572416c"
    "72656164794578697374733a312e30001500000041646170746572416c72"
    "656164794578697374730000000000000000";
    _marshaller_PortableServer_POA_AdapterAlreadyExists = new _Marshaller_PortableServer_POA_AdapterAlreadyExists;
    PortableServer::POA::_tc_AdapterInactive =
    "010000001600000054000000010000003300000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f41646170746572496e"
    "6163746976653a312e3000001000000041646170746572496e6163746976"
    "650000000000";
    _marshaller_PortableServer_POA_AdapterInactive = new _Marshaller_PortableServer_POA_AdapterInactive;
    PortableServer::POA::_tc_AdapterNonExistent =
    "01000000160000005c000000010000003600000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f416461707465724e6f"
    "6e4578697374656e743a312e3000000013000000416461707465724e6f6e"
    "4578697374656e74000000000000";
    _marshaller_PortableServer_POA_AdapterNonExistent = new _Marshaller_PortableServer_POA_AdapterNonExistent;
    PortableServer::POA::_tc_InvalidPolicy =
    "010000001600000064000000010000003100000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f496e76616c6964506f"
    "6c6963793a312e30000000000e000000496e76616c6964506f6c69637900"
    "00000100000006000000696e64657800000004000000";
    _marshaller_PortableServer_POA_InvalidPolicy = new _Marshaller_PortableServer_POA_InvalidPolicy;
    PortableServer::POA::_tc_NoServant =
    "01000000160000004c000000010000002d00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f4e6f53657276616e74"
    "3a312e30000000000a0000004e6f53657276616e7400000000000000";
    _marshaller_PortableServer_POA_NoServant = new _Marshaller_PortableServer_POA_NoServant;
    PortableServer::POA::_tc_ObjectAlreadyActive =
    "01000000160000005c000000010000003700000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f4f626a656374416c72"
    "656164794163746976653a312e300000140000004f626a656374416c7265"
    "6164794163746976650000000000";
    _marshaller_PortableServer_POA_ObjectAlreadyActive = new _Marshaller_PortableServer_POA_ObjectAlreadyActive;
    PortableServer::POA::_tc_ObjectNotActive =
    "010000001600000054000000010000003300000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f4f626a6563744e6f74"
    "4163746976653a312e300000100000004f626a6563744e6f744163746976"
    "650000000000";
    _marshaller_PortableServer_POA_ObjectNotActive = new _Marshaller_PortableServer_POA_ObjectNotActive;
    PortableServer::POA::_tc_ServantAlreadyActive =
    "010000001600000060000000010000003800000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f53657276616e74416c"
    "72656164794163746976653a312e30001500000053657276616e74416c72"
    "656164794163746976650000000000000000";
    _marshaller_PortableServer_POA_ServantAlreadyActive = new _Marshaller_PortableServer_POA_ServantAlreadyActive;
    PortableServer::POA::_tc_ServantNotActive =
    "010000001600000058000000010000003400000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f53657276616e744e6f"
    "744163746976653a312e30001100000053657276616e744e6f7441637469"
    "76650000000000000000";
    _marshaller_PortableServer_POA_ServantNotActive = new _Marshaller_PortableServer_POA_ServantNotActive;
    PortableServer::POA::_tc_WrongAdapter =
    "010000001600000050000000010000003000000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f57726f6e6741646170"
    "7465723a312e30000d00000057726f6e6741646170746572000000000000"
    "0000";
    _marshaller_PortableServer_POA_WrongAdapter = new _Marshaller_PortableServer_POA_WrongAdapter;
    PortableServer::POA::_tc_WrongPolicy =
    "01000000160000004c000000010000002f00000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f504f412f57726f6e67506f6c69"
    "63793a312e3000000c00000057726f6e67506f6c6963790000000000";
    _marshaller_PortableServer_POA_WrongPolicy = new _Marshaller_PortableServer_POA_WrongPolicy;
    PortableServer::Current::_tc_NoContext =
    "010000001600000050000000010000003100000049444c3a6f6d672e6f72"
    "672f506f727461626c655365727665722f43757272656e742f4e6f436f6e"
    "746578743a312e30000000000a0000004e6f436f6e746578740000000000"
    "0000";
    _marshaller_PortableServer_Current_NoContext = new _Marshaller_PortableServer_Current_NoContext;
    _marshaller__seq_PortableServer_POA = new _Marshaller__seq_PortableServer_POA;
  }
};

static __tc_init_POA __init_POA;
# 41 "orb_all.cc" 2
# 1 "poa_base.cc" 1
# 23 "poa_base.cc"
# 1 "../include/CORBA.h" 1
# 24 "poa_base.cc" 2
# 1 "../include/mico/throw.h" 1
# 25 "poa_base.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 26 "poa_base.cc" 2



namespace PortableServer {
    POA_ptr _the_root_poa = POA::_nil();
    Current_ptr _the_poa_current = Current::_nil();
};
# 44 "poa_base.cc"
PortableServer::ServantBase::ServantBase ()
{
  _my_poa = __null;
}

PortableServer::ServantBase::ServantBase (const ServantBase &)
{
  _my_poa = __null;
}

PortableServer::ServantBase::~ServantBase ()
{
}

PortableServer::ServantBase &
PortableServer::ServantBase::operator= (const ServantBase &)
{
  return *this;
}

PortableServer::POA_ptr
PortableServer::ServantBase::_default_POA ()
{
  if (!CORBA::is_nil (PortableServer::_the_root_poa)) {
    return PortableServer::POA::_duplicate(PortableServer::_the_root_poa);
  }
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var poaobj = orb->resolve_initial_references ("RootPOA");
  return PortableServer::POA::_narrow (poaobj);
}

CORBA::Boolean
PortableServer::ServantBase::_is_a (const char *)
{
  return 0;
}

CORBA::InterfaceDef_ptr
PortableServer::ServantBase::_get_interface (const char *repoid)
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    return CORBA::InterfaceDef::_nil ();
  }

  CORBA::Contained_var cv = ifr->lookup_id (repoid);
  return CORBA::InterfaceDef::_narrow (cv);
}

CORBA::Boolean
PortableServer::ServantBase::_non_existent ()
{
  return 0;
}

CORBA::Object_ptr
PortableServer::ServantBase::_this ()
{
  if (!CORBA::is_nil (_the_poa_current) &&
      _the_poa_current->iscurrent() &&
      _the_poa_current->get_serv() == (Servant) this) {
    return _the_poa_current->make_ref ();
  }

  PortableServer::POA_var poa;
  if (!CORBA::is_nil (_my_poa)) {
    poa = PortableServer::POA::_duplicate (_my_poa);
  }
  else {
    poa = _default_POA ();
  }

  return poa->activate_for_this (this);
}

void
PortableServer::ServantBase::_add_ref ()
{

}

void
PortableServer::ServantBase::_remove_ref ()
{

}

void
PortableServer::ServantBase::_check ()
{

}

CORBA::Object_ptr
PortableServer::ServantBase::_make_stub (PortableServer::POA_ptr,
                                         CORBA::Object_ptr)
{
  return CORBA::Object::_nil ();
}

void *
PortableServer::ServantBase::_narrow_helper (const char *)
{
  return __null;
}

PortableServer::POA_ptr
PortableServer::ServantBase::_activated_in ()
{
  return _my_poa;
}

void
PortableServer::ServantBase::_activated_in (PortableServer::POA_ptr __my_poa)
{
  _my_poa = __my_poa;
}





PortableServer::RefCountServantBase::RefCountServantBase ()
  : _magic (100800884), _ref_count (1)
{
}

PortableServer::RefCountServantBase::RefCountServantBase (const RefCountServantBase &)
  : _magic (100800884), _ref_count (1)
{
}

PortableServer::RefCountServantBase::~RefCountServantBase ()
{
  _magic = 0;
}

PortableServer::RefCountServantBase &
PortableServer::RefCountServantBase::operator= (const RefCountServantBase &)
{
  _check ();
  return *this;
}

void
PortableServer::RefCountServantBase::_add_ref ()
{
  _check ();
  _ref_count++;
}

void
PortableServer::RefCountServantBase::_remove_ref ()
{
  _check ();
  if (--_ref_count == 0) {
    delete this;
  }
}

void
PortableServer::RefCountServantBase::_check ()
{
  ((void) ((_magic == 100800884) ? 0 : (__assert_fail ("_magic == 100800884", "poa_base.cc", 210, __PRETTY_FUNCTION__), 0)));
}





PortableServer::ValueRefCountBase::ValueRefCountBase ()
{
}

PortableServer::ValueRefCountBase::ValueRefCountBase (const ValueRefCountBase &)
{
}

PortableServer::ValueRefCountBase::~ValueRefCountBase ()
{
}

void
PortableServer::ValueRefCountBase::_add_ref ()
{
  CORBA::DefaultValueRefCountBase::_add_ref ();
}

void
PortableServer::ValueRefCountBase::_remove_ref ()
{
  CORBA::DefaultValueRefCountBase::_remove_ref ();
}

CORBA::ULong
PortableServer::ValueRefCountBase::_refcount_value ()
{
  return CORBA::DefaultValueRefCountBase::_refcount_value ();
}





PortableServer::DynamicImplementation::~DynamicImplementation ()
{
}

CORBA::ServerRequestBase_ptr
PortableServer::DynamicImplementation::make_request (CORBA::ORBRequest *req,
                                                     CORBA::Object_ptr obj,
                                                     CORBA::ULong msgid,
                                                     CORBA::ObjectAdapter *oa,
                                                     CORBA::Principal_ptr pr)
{
  return new CORBA::ServerRequest (req, obj, msgid, oa, pr);
}

void
PortableServer::DynamicImplementation::doinvoke (CORBA::ServerRequestBase_ptr req)
{
  invoke ((CORBA::ServerRequest_ptr) req);
}

CORBA::Object_ptr
PortableServer::DynamicImplementation::_this ()
{
  return PortableServer::ServantBase::_this ();
}

CORBA::Boolean
PortableServer::DynamicImplementation::_is_a (const char * repoid)
{






  PortableServer::ObjectId_var oid;
  PortableServer::POA_var poa;

  if (!CORBA::is_nil (_the_poa_current) &&
      _the_poa_current->iscurrent() &&
      _the_poa_current->get_serv() == (Servant) this) {
    poa = _the_poa_current->get_POA ();
    oid = _the_poa_current->get_object_id ();
  }
  else {
    if (!CORBA::is_nil (_my_poa)) {
      poa = PortableServer::POA::_duplicate (_my_poa);
    }
    else {
      poa = _default_POA ();
    }
    CORBA::Object_var obj = poa->activate_for_this (this);
    oid = poa->reference_to_id (obj);
  }

  CORBA::String_var pif = _primary_interface (oid.in(), poa.in());

  if (strcmp (pif.in(), repoid) == 0) {
    return 1;
  }





  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id (pif.in());
  CORBA::InterfaceDef_var ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd->is_a (repoid);
}

CORBA::InterfaceDef_ptr
PortableServer::DynamicImplementation::_get_interface ()
{






  PortableServer::ObjectId_var oid;
  PortableServer::POA_var poa;

  if (!CORBA::is_nil (_the_poa_current) &&
      _the_poa_current->iscurrent() &&
      _the_poa_current->get_serv() == (Servant) this) {
    poa = _the_poa_current->get_POA ();
    oid = _the_poa_current->get_object_id ();
  }
  else {
    if (!CORBA::is_nil (_my_poa)) {
      poa = PortableServer::POA::_duplicate (_my_poa);
    }
    else {
      poa = _default_POA ();
    }
    CORBA::Object_var obj = poa->activate_for_this (this);
    oid = poa->reference_to_id (obj);
  }

  CORBA::String_var pif = _primary_interface (oid.in(), poa.in());





  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id (pif.in());
  CORBA::InterfaceDef_ptr ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}





PortableServer::StaticImplementation::~StaticImplementation ()
{
}

CORBA::ServerRequestBase_ptr
PortableServer::StaticImplementation::make_request (CORBA::ORBRequest *req,
                                                    CORBA::Object_ptr obj,
                                                    CORBA::ULong msgid,
                                                    CORBA::ObjectAdapter *oa,
                                                    CORBA::Principal_ptr pr)
{
  return new CORBA::StaticServerRequest (req, obj, msgid, oa, pr);
}

void
PortableServer::StaticImplementation::doinvoke (CORBA::ServerRequestBase_ptr req)
{
  invoke ((CORBA::StaticServerRequest_ptr) req);
}






PortableServer::StubBase::StubBase (PortableServer::POA_ptr poa)
{
  _colocated_poa = PortableServer::POA::_duplicate (poa);
}

PortableServer::StubBase::StubBase ()
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 423, __PRETTY_FUNCTION__), 0)));
}

PortableServer::StubBase::~StubBase ()
{
  CORBA::release (_colocated_poa);
}

PortableServer::Servant
PortableServer::StubBase::_preinvoke ()
{
  if (CORBA::is_nil (_colocated_poa)) {
    return __null;
  }

  PortableServer::Servant serv = _colocated_poa->preinvoke (this);

  if (serv == __null) {
    CORBA::release (_colocated_poa);
    _colocated_poa = PortableServer::POA::_nil ();
    return __null;
  }

  return serv;
}

void
PortableServer::StubBase::_postinvoke ()
{
  _colocated_poa->postinvoke ();
}





char *
PortableServer::ObjectId_to_string (const PortableServer::ObjectId & oid)
{
  char * s = CORBA::string_alloc (oid.length());

  for (CORBA::ULong i = 0; i < oid.length(); ++i) {
    if (!(CORBA::Octet)oid[i]) {
      CORBA::string_free (s);
      mico_throw (CORBA::BAD_PARAM());
    }
    s[i] = (CORBA::Octet)oid[i];
  }

  s[oid.length()] = 0;
  return s;
}

PortableServer::ObjectId *
PortableServer::string_to_ObjectId (const char * s)
{
  if (!s) {
    mico_throw (CORBA::BAD_PARAM());
  }

  CORBA::ULong len = strlen (s);

  PortableServer::ObjectId *oid = new PortableServer::ObjectId;
  oid->length (len);

  for (CORBA::ULong i = 0; i < len; ++i) {
    (*oid)[i] = (CORBA::Octet)s[i];
  }
  return oid;
}

CORBA::WChar *
PortableServer::ObjectId_to_wstring (const PortableServer::ObjectId & oid)
{
  if ((oid.length() % 4) != 0) {
    mico_throw (CORBA::BAD_PARAM());
  }

  CORBA::WChar * s = CORBA::wstring_alloc (oid.length() / 4);

  for (CORBA::ULong i=0; i < oid.length()/4; i++) {
    unsigned long c =
      oid[4*i] + 256*oid[4*i+1] + 65536*oid[4*i+2] + 16777216*oid[4*i+3];
    if (c == 0) {
      CORBA::wstring_free (s);
      mico_throw (CORBA::BAD_PARAM());
    }
    s[i] = (wchar_t) c;
  }

  s[oid.length()/4] = 0;
  return s;
}

PortableServer::ObjectId *
PortableServer::wstring_to_ObjectId (const CORBA::WChar * s)
{
  if (!s) {
    mico_throw (CORBA::BAD_PARAM());
  }

  CORBA::ULong len;

  for (len=0; s[len]; len++);

  PortableServer::ObjectId *oid = new PortableServer::ObjectId;
  oid->length (4*len);

  for (CORBA::ULong i = 0; i < len; ++i) {
    (*oid)[4*i] = ((unsigned long) s[i]) % 256;
    (*oid)[4*i+1] = ((unsigned long) s[i] / 256) % 256;
    (*oid)[4*i+2] = ((unsigned long) s[i] / 65536) % 256;
    (*oid)[4*i+3] = ((unsigned long) s[i] / 16777216) % 256;
  }
  return oid;
}
# 548 "poa_base.cc"
PortableServer::AdapterActivator_stub_clp::AdapterActivator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : PortableServer::StubBase (poa), CORBA::Object (*obj)
{
}

PortableServer::AdapterActivator_stub_clp::~AdapterActivator_stub_clp ()
{
}

CORBA::Boolean
PortableServer::AdapterActivator_stub_clp::unknown_adapter( PortableServer::POA_ptr parent, const char* name )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_PortableServer::AdapterActivator * _myserv = POA_PortableServer::AdapterActivator::_narrow (_serv);
    if (_myserv) {
      CORBA::Boolean res;


      try {

        res = _myserv->unknown_adapter(parent, name);

      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }


      _myserv->_remove_ref();
      _postinvoke ();
      return res;
    }
    _postinvoke ();
  }

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 586, __PRETTY_FUNCTION__), 0)));
  return 0;
}

PortableServer::ServantManager_stub_clp::ServantManager_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : PortableServer::StubBase (poa), CORBA::Object (*obj)
{
}

PortableServer::ServantManager_stub_clp::~ServantManager_stub_clp ()
{
}

PortableServer::ServantActivator_stub_clp::ServantActivator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : PortableServer::StubBase (poa), CORBA::Object (*obj),
  PortableServer::ServantManager_stub_clp (poa, obj)
{
}

PortableServer::ServantActivator_stub_clp::~ServantActivator_stub_clp ()
{
}

PortableServer::Servant
PortableServer::ServantActivator_stub_clp::incarnate( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_PortableServer::ServantActivator * _myserv = POA_PortableServer::ServantActivator::_narrow (_serv);
    if (_myserv) {
      PortableServer::Servant res;


      try {

        res = _myserv->incarnate(oid, adapter);

      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }


      _myserv->_remove_ref();
      _postinvoke ();
      return res;
    }
    _postinvoke ();
  }

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 638, __PRETTY_FUNCTION__), 0)));
  return __null;
}

void
PortableServer::ServantActivator_stub_clp::etherealize( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, PortableServer::Servant serv, CORBA::Boolean cleanup_in_progress, CORBA::Boolean remaining_activations )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_PortableServer::ServantActivator * _myserv = POA_PortableServer::ServantActivator::_narrow (_serv);
    if (_myserv) {

      try {

        _myserv->etherealize(oid, adapter, serv, cleanup_in_progress, remaining_activations);

      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }


      _myserv->_remove_ref();
      _postinvoke ();
      return;
    }
    _postinvoke ();
  }

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 669, __PRETTY_FUNCTION__), 0)));
}

PortableServer::ServantLocator_stub_clp::ServantLocator_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : PortableServer::StubBase (poa), CORBA::Object (*obj),
  PortableServer::ServantManager_stub_clp (poa, obj)
{
}

PortableServer::ServantLocator_stub_clp::~ServantLocator_stub_clp ()
{
}

PortableServer::Servant
PortableServer::ServantLocator_stub_clp::preinvoke( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie& the_cookie )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_PortableServer::ServantLocator * _myserv = POA_PortableServer::ServantLocator::_narrow (_serv);
    if (_myserv) {
      PortableServer::Servant res;


      try {

        res = _myserv->preinvoke(oid, adapter, operation, the_cookie);

      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }


      _myserv->_remove_ref();
      _postinvoke ();
      return res;
    }
    _postinvoke ();
  }

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 711, __PRETTY_FUNCTION__), 0)));
  return __null;
}

void
PortableServer::ServantLocator_stub_clp::postinvoke( const PortableServer::ObjectId& oid, PortableServer::POA_ptr adapter, const char* operation, PortableServer::ServantLocator::Cookie the_cookie, PortableServer::Servant the_servant )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_PortableServer::ServantLocator * _myserv = POA_PortableServer::ServantLocator::_narrow (_serv);
    if (_myserv) {

      try {

        _myserv->postinvoke(oid, adapter, operation, the_cookie, the_servant);

      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }


      _myserv->_remove_ref();
      _postinvoke ();
      return;
    }
    _postinvoke ();
  }

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 742, __PRETTY_FUNCTION__), 0)));
}


POA_PortableServer::AdapterActivator::~AdapterActivator()
{
}

PortableServer::AdapterActivator_ptr
POA_PortableServer::AdapterActivator::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this ();
  return PortableServer::AdapterActivator::_narrow (obj);
}

CORBA::Boolean
POA_PortableServer::AdapterActivator::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/PortableServer/AdapterActivator:1.0") == 0) {
    return 1;
  }
  return 0;
}

CORBA::InterfaceDef_ptr
POA_PortableServer::AdapterActivator::_get_interface ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/PortableServer/AdapterActivator:1.0");
  CORBA::InterfaceDef_ptr ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_PortableServer::AdapterActivator::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:omg.org/PortableServer/AdapterActivator:1.0");
}

void *
POA_PortableServer::AdapterActivator::_narrow_helper (const char * repoid)
{

  if (strcmp (repoid, "IDL:omg.org/PortableServer/AdapterActivator:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

POA_PortableServer::AdapterActivator *
POA_PortableServer::AdapterActivator::_narrow (PortableServer::Servant serv)
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:omg.org/PortableServer/AdapterActivator:1.0")) != __null) {
    serv->_add_ref ();
    return (POA_PortableServer::AdapterActivator *) p;
  }
  return __null;
}

CORBA::Object_ptr
POA_PortableServer::AdapterActivator::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new PortableServer::AdapterActivator_stub_clp (poa, obj);
}

bool
POA_PortableServer::AdapterActivator::dispatch (CORBA::ServerRequest_ptr)
{
  return 0;
}

void
POA_PortableServer::AdapterActivator::invoke (CORBA::ServerRequest_ptr)
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 829, __PRETTY_FUNCTION__), 0)));
}



POA_PortableServer::ServantManager::~ServantManager()
{
}

PortableServer::ServantManager_ptr
POA_PortableServer::ServantManager::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this ();
  return PortableServer::ServantManager::_narrow (obj);
}

CORBA::Boolean
POA_PortableServer::ServantManager::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantManager:1.0") == 0) {
    return 1;
  }
  return 0;
}

CORBA::InterfaceDef_ptr
POA_PortableServer::ServantManager::_get_interface ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/PortableServer/ServantManager:1.0");
  CORBA::InterfaceDef_ptr ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_PortableServer::ServantManager::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:omg.org/PortableServer/ServantManager:1.0");
}

void *
POA_PortableServer::ServantManager::_narrow_helper (const char * repoid)
{

  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantManager:1.0") == 0) {
    return (void *) this;
  }
  return __null;
}

POA_PortableServer::ServantManager *
POA_PortableServer::ServantManager::_narrow (PortableServer::Servant serv)
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:omg.org/PortableServer/ServantManager:1.0")) != __null) {
    serv->_add_ref ();
    return (POA_PortableServer::ServantManager *) p;
  }
  return __null;
}

CORBA::Object_ptr
POA_PortableServer::ServantManager::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new PortableServer::ServantManager_stub_clp (poa, obj);
}

bool
POA_PortableServer::ServantManager::dispatch (CORBA::ServerRequest_ptr)
{
  return 0;
}

void
POA_PortableServer::ServantManager::invoke (CORBA::ServerRequest_ptr)
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 917, __PRETTY_FUNCTION__), 0)));
}



POA_PortableServer::ServantActivator::~ServantActivator()
{
}

PortableServer::ServantActivator_ptr
POA_PortableServer::ServantActivator::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this ();
  return PortableServer::ServantActivator::_narrow (obj);
}

CORBA::Boolean
POA_PortableServer::ServantActivator::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantActivator:1.0") == 0) {
    return 1;
  }
  if (POA_PortableServer::ServantManager::_is_a (repoid)) {
    return 1;
  }
  return 0;
}

CORBA::InterfaceDef_ptr
POA_PortableServer::ServantActivator::_get_interface ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/PortableServer/ServantActivator:1.0");
  CORBA::InterfaceDef_ptr ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_PortableServer::ServantActivator::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:omg.org/PortableServer/ServantActivator:1.0");
}

void *
POA_PortableServer::ServantActivator::_narrow_helper (const char * repoid)
{
  void * p;
  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantActivator:1.0") == 0) {
    return (void *) this;
  }
  if ((p = POA_PortableServer::ServantManager::_narrow_helper (repoid)) != __null) {
    return p;
  }
  return __null;
}

POA_PortableServer::ServantActivator *
POA_PortableServer::ServantActivator::_narrow (PortableServer::Servant serv)
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:omg.org/PortableServer/ServantActivator:1.0")) != __null) {
    serv->_add_ref ();
    return (POA_PortableServer::ServantActivator *) p;
  }
  return __null;
}

CORBA::Object_ptr
POA_PortableServer::ServantActivator::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new PortableServer::ServantActivator_stub_clp (poa, obj);
}

bool
POA_PortableServer::ServantActivator::dispatch (CORBA::ServerRequest_ptr)
{
  return 0;
}

void
POA_PortableServer::ServantActivator::invoke (CORBA::ServerRequest_ptr)
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 1011, __PRETTY_FUNCTION__), 0)));
}



POA_PortableServer::ServantLocator::~ServantLocator()
{
}

PortableServer::ServantLocator_ptr
POA_PortableServer::ServantLocator::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this ();
  return PortableServer::ServantLocator::_narrow (obj);
}

CORBA::Boolean
POA_PortableServer::ServantLocator::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantLocator:1.0") == 0) {
    return 1;
  }
  if (POA_PortableServer::ServantManager::_is_a (repoid)) {
    return 1;
  }
  return 0;
}

CORBA::InterfaceDef_ptr
POA_PortableServer::ServantLocator::_get_interface ()
{
  CORBA::ORB_var orb = CORBA::ORB_instance ("mico-local-orb");
  CORBA::Object_var irobj =
    orb->resolve_initial_references ("InterfaceRepository");
  CORBA::Repository_var ifr = CORBA::Repository::_narrow (irobj);
  if (CORBA::is_nil (ifr)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  CORBA::Contained_var cv = ifr->lookup_id ("IDL:omg.org/PortableServer/ServantLocator:1.0");
  CORBA::InterfaceDef_ptr ifd = CORBA::InterfaceDef::_narrow (cv);

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_PortableServer::ServantLocator::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:omg.org/PortableServer/ServantLocator:1.0");
}

void *
POA_PortableServer::ServantLocator::_narrow_helper (const char * repoid)
{
  void * p;
  if (strcmp (repoid, "IDL:omg.org/PortableServer/ServantLocator:1.0") == 0) {
    return (void *) this;
  }
  if ((p = POA_PortableServer::ServantManager::_narrow_helper (repoid)) != __null) {
    return p;
  }
  return __null;
}

POA_PortableServer::ServantLocator *
POA_PortableServer::ServantLocator::_narrow (PortableServer::Servant serv)
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:omg.org/PortableServer/ServantLocator:1.0")) != __null) {
    serv->_add_ref ();
    return (POA_PortableServer::ServantLocator *) p;
  }
  return __null;
}

CORBA::Object_ptr
POA_PortableServer::ServantLocator::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new PortableServer::ServantLocator_stub_clp (poa, obj);
}

bool
POA_PortableServer::ServantLocator::dispatch (CORBA::ServerRequest_ptr)
{
  return 0;
}

void
POA_PortableServer::ServantLocator::invoke (CORBA::ServerRequest_ptr)
{
  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_base.cc", 1105, __PRETTY_FUNCTION__), 0)));
}
# 42 "orb_all.cc" 2
# 1 "poa_impl.cc" 1
# 27 "poa_impl.cc"
# 1 "../include/CORBA.h" 1
# 28 "poa_impl.cc" 2
# 1 "../include/mico/impl.h" 1
# 29 "poa_impl.cc" 2
# 1 "../include/mico/throw.h" 1
# 30 "poa_impl.cc" 2
# 1 "../include/mico/util.h" 1
# 31 "poa_impl.cc" 2
# 1 "../include/mico/os-net.h" 1
# 32 "poa_impl.cc" 2
# 1 "../include/mico/poa_impl.h" 1
# 33 "poa_impl.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 34 "poa_impl.cc" 2






namespace MICOPOA {
  POAOptions poaopts;
};




MICOPOA::POA_impl::POAMap MICOPOA::POA_impl::AllPOAs;
MICOPOA::UniqueIdGenerator MICOPOA::POA_impl::poauid;
MICOPOA::UniqueIdGenerator MICOPOA::POA_impl::idfactory ("_");
MICOPOA::POACurrent_impl * MICOPOA::POA_impl::current = __null;

string MICOPOA::POA_impl::oaprefix;
string MICOPOA::POA_impl::impl_name;
CORBA::IOR MICOPOA::POA_impl::poamed_ior;
CORBA::POAMediator_var MICOPOA::POA_impl::poamed;
CORBA::Boolean MICOPOA::POA_impl::ever_been_active;
# 66 "poa_impl.cc"
static class POAInit : public Interceptor::InitInterceptor {
public:
  POAInit ()
    : Interceptor::InitInterceptor (0)
  {
  }

  ~POAInit ()
  {
    deactivate ();
  }

  Interceptor::Status initialize (CORBA::ORB_ptr orb, const char *orbid,
                                  int &argc, char *argv[])
  {
    if (!MICOPOA::poaopts.parse (orb, argc, argv))
      return Interceptor::INVOKE_ABORT;
    return Interceptor::INVOKE_CONTINUE;
  }
} InitPOA;

void
MICOPOA::_init ()
{
  (void) InitPOA;
}





CORBA::Boolean
MICOPOA::POAOptions::parse (CORBA::ORB_ptr orb, int &argc, char *argv[])
{
  MICOGetOpt::OptMap opts;
  opts["-POARemoteIOR"] = "arg-expected";
  opts["-POAImplName"] = "arg-expected";
  opts["-POARemoteAddr"] = "arg-expected";

  MICOGetOpt opt_parser (opts);
  CORBA::Boolean r = opt_parser.parse (orb->rcfile(), 1);
  if (!r) return 0;
  r = opt_parser.parse (argc, argv, 1);
  if (!r) return 0;
  const MICOGetOpt::OptVec &o = opt_parser.opts();

  for (MICOGetOpt::OptVec::const_iterator i = o.begin(); i != o.end(); ++i) {
    string arg = (*i).first;
    string val = (*i).second;
    options[arg] = val;
  }
  return 1;
}

const char *
MICOPOA::POAOptions::operator[] (const char * opt)
{
  map<string,string,less<string> >::iterator it = options.find (opt);
  if (it == options.end()) {
    return __null;
  }
  return (*it).second.c_str();
}
# 138 "poa_impl.cc"
MICOPOA::POAManager_impl::POAManager_impl ()
{
  _state = HOLDING;
}

MICOPOA::POAManager_impl::~POAManager_impl ()
{
}

PortableServer::POAManager::State
MICOPOA::POAManager_impl::get_state ()
{
  return _state;
}

void
MICOPOA::POAManager_impl::add_managed_poa (PortableServer::POA_ptr poa)
{
  managed.push_back (poa);
}

void
MICOPOA::POAManager_impl::del_managed_poa (PortableServer::POA_ptr poa)
{
  vector<PortableServer::POA_ptr>::iterator it = managed.begin ();

  while (it != managed.end()) {
    if (*it == poa) {
      managed.erase (it);
      return;
    }
    it++;
  }
}

void
MICOPOA::POAManager_impl::change_state (State s,
                                        CORBA::Boolean etherealize_objects,
                                        CORBA::Boolean wait_for_completion)
{
  if (_state == INACTIVE) {
    mico_throw (PortableServer::POAManager::AdapterInactive());
  }

  if (_state == s) {
    return;
  }

  _state = s;

  vector<PortableServer::POA_ptr>::iterator it = managed.begin();

  while (it != managed.end()) {
    (*it)->poa_manager_callback (_state,
                                 etherealize_objects,
                                 wait_for_completion);
    it++;
  }
}

void
MICOPOA::POAManager_impl::activate ()
{
  change_state (ACTIVE);
}

void
MICOPOA::POAManager_impl::hold_requests (CORBA::Boolean wait_for_completion)
{
  change_state (HOLDING, 0, wait_for_completion);
}

void
MICOPOA::POAManager_impl::discard_requests (CORBA::Boolean wait_for_completion)
{
  change_state (DISCARDING, 0, wait_for_completion);
}

void
MICOPOA::POAManager_impl::deactivate (CORBA::Boolean etherealize_objects,
                                      CORBA::Boolean wait_for_completion)
{
  change_state (INACTIVE,
                etherealize_objects,
                wait_for_completion);
}
# 233 "poa_impl.cc"
MICOPOA::POACurrent_impl::CurrentState::CurrentState ()
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 236, __PRETTY_FUNCTION__), 0)));
}

MICOPOA::POACurrent_impl::CurrentState::CurrentState (PortableServer::POA_ptr _poa, POAObjectReference * _por, PortableServer::Servant _serv)
{
  poa = _poa;
  por = _por;
  serv = _serv;
  serv->_add_ref ();
}

MICOPOA::POACurrent_impl::CurrentState::CurrentState (const CurrentState & o)
{
  poa = o.poa;
  por = o.por;
  serv = o.serv;
  serv->_add_ref ();
}

MICOPOA::POACurrent_impl::CurrentState::~CurrentState ()
{
  serv->_remove_ref ();
}

MICOPOA::POACurrent_impl::POACurrent_impl (CORBA::ORB_ptr _orb)
{
  ((void) ((CORBA::is_nil (PortableServer::_the_poa_current)) ? 0 : (__assert_fail ("CORBA::is_nil (PortableServer::_the_poa_current)", "poa_impl.cc", 262, __PRETTY_FUNCTION__), 0)));
  PortableServer::_the_poa_current = this;
  orb = _orb;
  orb->set_initial_reference ("POACurrent", this);
}

MICOPOA::POACurrent_impl::~POACurrent_impl ()
{
  PortableServer::_the_poa_current = __null;
}

PortableServer::POA_ptr
MICOPOA::POACurrent_impl::get_POA ()
{
  if (CurrentStateStack.empty()) {
    mico_throw (PortableServer::Current::NoContext());
  }
  return PortableServer::POA::_duplicate (CurrentStateStack.back().poa);
}

PortableServer::ObjectId *
MICOPOA::POACurrent_impl::get_object_id ()
{
  if (CurrentStateStack.empty()) {
    mico_throw (PortableServer::Current::NoContext());
  }
  return CurrentStateStack.back().por->id();
}

CORBA::Boolean
MICOPOA::POACurrent_impl::iscurrent ()
{
  return !CurrentStateStack.empty();
}

CORBA::Object_ptr
MICOPOA::POACurrent_impl::make_ref ()
{
  ((void) ((iscurrent()) ? 0 : (__assert_fail ("iscurrent()", "poa_impl.cc", 300, __PRETTY_FUNCTION__), 0)));
  return CurrentStateStack.back().por->ref();
}

PortableServer::Servant
MICOPOA::POACurrent_impl::get_serv ()
{
  ((void) ((iscurrent()) ? 0 : (__assert_fail ("iscurrent()", "poa_impl.cc", 307, __PRETTY_FUNCTION__), 0)));
  return CurrentStateStack.back().serv;
}

MICOPOA::POAObjectReference *
MICOPOA::POACurrent_impl::get_por ()
{
  ((void) ((iscurrent()) ? 0 : (__assert_fail ("iscurrent()", "poa_impl.cc", 314, __PRETTY_FUNCTION__), 0)));
  return CurrentStateStack.back().por;
}

void
MICOPOA::POACurrent_impl::set (PortableServer::POA_ptr _poa,
                               POAObjectReference * _por,
                               PortableServer::Servant _serv)
{
  CurrentStateStack.push_back (CurrentState (_poa, _por, _serv));
}

void
MICOPOA::POACurrent_impl::unset ()
{
  ((void) ((iscurrent()) ? 0 : (__assert_fail ("iscurrent()", "poa_impl.cc", 329, __PRETTY_FUNCTION__), 0)));
  CurrentStateStack.pop_back();
}
# 345 "poa_impl.cc"
MICOPOA::ObjectId::ObjectId ()
{
  octets = __null;
  oid = __null;
}

MICOPOA::ObjectId::ObjectId (const ObjectId & id, bool copy)
{
  oid = __null;
  idlength = id.idlength;
  if ((own = copy)) {
    octets = CORBA::string_alloc (idlength);
    memcpy (octets, id.octets, idlength);
  }
  else {
    octets = (char *) id.octets;
  }
}

MICOPOA::ObjectId::ObjectId (const PortableServer::ObjectId & id)
{
  own = 1;
  oid = __null;
  idlength = id.length ();
  octets = CORBA::string_alloc (idlength);

  for (CORBA::ULong i=0; i<idlength; i++) {
    octets[i] = (char) id[i];
  }
}

MICOPOA::ObjectId::ObjectId (const char * id, CORBA::ULong len, bool copy)
{
  oid = __null;
  idlength = len;
  if ((own = copy)) {
    octets = CORBA::string_alloc (idlength);
    memcpy (octets, id, idlength);
  }
  else {
    octets = (char *) id;
  }
}

MICOPOA::ObjectId::~ObjectId ()
{
  if (own) {
    CORBA::string_free (octets);
  }
  delete oid;
}

MICOPOA::ObjectId &
MICOPOA::ObjectId::operator= (const ObjectId & id)
{
  if (own) {
    CORBA::string_free (octets);
  }
  delete oid;
  oid = __null;
  own = 1;
  idlength = id.idlength;
  octets = CORBA::string_alloc (idlength);
  memcpy (octets, id.octets, idlength);
  return *this;
}

CORBA::Boolean
MICOPOA::ObjectId::operator== (const ObjectId & o)
{
  if (idlength != o.idlength) {
    return 0;
  }

  return (memcmp (octets, o.octets, idlength) == 0);
}

bool
MICOPOA::ObjectId::operator< (const ObjectId & o) const
{
  if (idlength != o.idlength) {
    return (idlength < o.idlength);
  }

  return (memcmp (octets, o.octets, idlength) < 0);
}

const char *
MICOPOA::ObjectId::get_data (CORBA::ULong & len) const
{
  len = idlength;
  return octets;
}

const PortableServer::ObjectId &
MICOPOA::ObjectId::get_id ()
{
  if (!oid) {
    oid = new PortableServer::ObjectId;
    oid->length (idlength);

    for (CORBA::ULong i=0; i<idlength; i++) {
      (*oid)[i] = (CORBA::Octet) octets[i];
    }
  }

  return *oid;
}

PortableServer::ObjectId *
MICOPOA::ObjectId::id ()
{
  return new PortableServer::ObjectId (get_id());
}





MICOPOA::POAObjectReference::POAObjectReference (POA_impl * _poa,
                                                 const PortableServer::ObjectId &_i,
                                                 const char * _repoid,
                                                 PortableServer::Servant _serv)
  : repoid (_repoid), oid (_i), servant (_serv)
{
  ((void) ((_poa) ? 0 : (__assert_fail ("_poa", "poa_impl.cc", 470, __PRETTY_FUNCTION__), 0)));
  ((void) ((_repoid) ? 0 : (__assert_fail ("_repoid", "poa_impl.cc", 471, __PRETTY_FUNCTION__), 0)));

  poa = _poa;
  poaname = poa->get_oaid();
  obj = CORBA::Object::_nil ();
  iddirty = 0;

  if (servant) {
    servant->_add_ref();
  }
}

MICOPOA::POAObjectReference::POAObjectReference (POA_impl * _poa,
                                                 CORBA::Object_ptr _obj)
  : poa (_poa)
{
  ((void) ((_poa) ? 0 : (__assert_fail ("_poa", "poa_impl.cc", 487, __PRETTY_FUNCTION__), 0)));
  poa = _poa;
  obj = CORBA::Object::_duplicate (_obj);
  iddirty = 1;
  servant = __null;
}

MICOPOA::POAObjectReference::POAObjectReference (const POAObjectReference &o)
  : oid (o.oid)
{
  poa = o.poa;
  poaname = o.poaname;
  repoid = o.repoid;
  obj = CORBA::Object::_duplicate (o.obj);
  iddirty = o.iddirty;
  servant = o.servant;

  if (servant) {
    servant->_add_ref();
  }
}

MICOPOA::POAObjectReference::~POAObjectReference ()
{
  CORBA::release (obj);
  if (servant) {
    servant->_remove_ref();
  }
}

void
MICOPOA::POAObjectReference::make_ref ()
{
  if (!CORBA::is_nil (obj)) {
# 529 "poa_impl.cc"
    if (obj->_ior() && obj->_ior()->profile() &&
        obj->_ior()->profile()->id() == 10000) {
      const CORBA::Octet * key;
      CORBA::Long length;
      key = obj->_ior()->profile()->objectkey (length);

      CORBA::IOR * ior = new CORBA::IOR (*poa->ior_template());
      ior->objectkey ((CORBA::Octet *) key, length);

      ior->objid (obj->_ior()->objid());

      CORBA::release (obj);
      obj = new CORBA::Object (ior);
      ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 542, __PRETTY_FUNCTION__), 0)));
      obj->_setup_domains (CORBA::Object::_nil());
    }

    return;
  }

  if (iddirty) {

    return;
  }
# 561 "poa_impl.cc"
  CORBA::ULong idlength, length = poaname.length();
  CORBA::Long i, j = poaname.length();
  CORBA::Boolean samename = 0;
  const char * iddata = oid.get_data (idlength);

  if (idlength == length) {
    for (i=0; i < (CORBA::Long) idlength; i++) {
      if (iddata[i] != poaname[i]) {
        break;
      }
    }
    if (i == (CORBA::Long) idlength) {
      samename = 1;
    }
  }

  if (!samename) {
    for (i=0; i < (CORBA::Long) idlength; i++) {
      if (iddata[i] == '/' || iddata[i] == '\\') {
        length++;
      }
      length++;
    }
    length++;
  }

  CORBA::Octet * key = (CORBA::Octet *) CORBA::string_alloc (length);
  memcpy (key, poaname.c_str(), j);

  if (!samename) {
    key[j++] = '/';
    for (i=0; i < (CORBA::Long) idlength; i++, j++) {
      if (iddata[i] == '/' || iddata[i] == '\\') {
        key[j++] = '\\';
      }
      key[j] = (CORBA::Octet) iddata[i];
    }
  }

  ((void) ((j == (CORBA::Long) length) ? 0 : (__assert_fail ("j == (CORBA::Long) length", "poa_impl.cc", 600, __PRETTY_FUNCTION__), 0)));

  CORBA::IOR * ior = new CORBA::IOR (*poa->ior_template());
  ior->objectkey (key, length);
  ior->objid (repoid.c_str());
  CORBA::string_free ((char *) key);

  obj = new CORBA::Object (ior);
  ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 608, __PRETTY_FUNCTION__), 0)));
  obj->_setup_domains (CORBA::Object::_nil());

  if (servant) {
    CORBA::Object_ptr stub = servant->_make_stub (poa, obj);
    if (!CORBA::is_nil (stub)) {
      CORBA::release (obj);
      obj = stub;
    }
  }
}

bool
MICOPOA::POAObjectReference::decompose_ref ()
{





  if (!iddirty) {

    return 1;
  }

  if (CORBA::is_nil (obj) || !obj->_ior() || !obj->_ior()->profile()) {
    return 0;
  }

  CORBA::Long i, j, length, idlength;
  const CORBA::Octet * key = obj->_ior()->profile()->objectkey (length);

  if (!key) {
    return 0;
  }





  for (i=length-1; i>0; i--) {
    if (key[i] == '/') {
      for (j=0; j<i; j++) {
        if (key[i-j-1] != '\\') {
          break;
        }
      }
      if ((j%2) == 0) {
        break;
      }
    }
  }

  if (key[i] != '/') {
    i = length;
  }

  for (j=0; j<i; j++) {
    if (!key[j]) {
      return 0;
    }
    poaname += key[j];
  }





  if (j == length) {
    oid = ObjectId (poaname.c_str(), (CORBA::ULong) length, 0);
  }
  else {
    j++;

    for (i=j, idlength=length-j; i<length; i++) {
      if (key[i] == '\\') {
        idlength--, i++;
      }
    }

    char * iddata = CORBA::string_alloc (idlength);

    for (i=0; j<length; i++, j++) {
      if (key[j] == '\\') {
        j++;
      }
      iddata[i] = key[j];
    }

    oid = ObjectId (iddata, (CORBA::ULong) idlength, 0);
    CORBA::string_free (iddata);
  }

  iddirty = 0;
  repoid = obj->_repoid ();
  return 1;
}

bool
MICOPOA::POAObjectReference::is_legal ()
{
  if (!iddirty) {
    return 1;
  }
  if (!CORBA::is_nil (obj)) {
    return decompose_ref ();
  }
  return 0;
}

const MICOPOA::ObjectId &
MICOPOA::POAObjectReference::get_oid ()
{
  if (iddirty) {
    bool r = decompose_ref ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "poa_impl.cc", 723, __PRETTY_FUNCTION__), 0)));
  }
  return oid;
}

CORBA::Object_ptr
MICOPOA::POAObjectReference::get_ref ()
{
  make_ref ();
  return obj;
}

void
MICOPOA::POAObjectReference::set_ref (CORBA::Object_ptr o)
{
    CORBA::release (obj);
    obj = CORBA::Object::_duplicate (o);
}

const PortableServer::ObjectId &
MICOPOA::POAObjectReference::get_id ()
{
  if (iddirty) {
    bool r = decompose_ref ();
    ((void) ((r) ? 0 : (__assert_fail ("r", "poa_impl.cc", 747, __PRETTY_FUNCTION__), 0)));
  }
  return oid.get_id();
}

CORBA::Object_ptr
MICOPOA::POAObjectReference::ref ()
{
  return CORBA::Object::_duplicate (get_ref());
}

PortableServer::ObjectId *
MICOPOA::POAObjectReference::id ()
{
  return new PortableServer::ObjectId (get_id());
}

MICOPOA::POAObjectReference &
MICOPOA::POAObjectReference::operator= (const CORBA::Object_ptr oref)
{

  iddirty = 1;
  CORBA::release (obj);
  obj = CORBA::Object::_duplicate (oref);
  return *this;
}

MICOPOA::POAObjectReference &
MICOPOA::POAObjectReference::operator= (const POAObjectReference &o)
{
  CORBA::release (obj);

  poa = o.poa;
  poaname = o.poaname;
  repoid = o.repoid;
  oid = o.oid;
  iddirty = o.iddirty;
  obj = CORBA::Object::_duplicate (o.obj);

  return *this;
}

const char *
MICOPOA::POAObjectReference::poa_name ()
{
  bool r = decompose_ref ();
  ((void) ((r) ? 0 : (__assert_fail ("r", "poa_impl.cc", 793, __PRETTY_FUNCTION__), 0)));
  return poaname.c_str();
}

bool
MICOPOA::POAObjectReference::in_poa (const char * pname)
{
  if (!decompose_ref()) {
    return 0;
  }

  const char * pstr = poaname.c_str();
  return !strcmp (pstr, pname);
}

bool
MICOPOA::POAObjectReference::in_descendant_poa (const char * fqn,
                                                const char * implname)
{
  if (!decompose_ref()) {
    return 0;
  }

  const char * pstr = poaname.c_str();

  if (*implname && strncmp (pstr, implname, strlen (implname)) == 0) {
    pstr += strlen (implname);
    if (!*pstr) {
      pstr = poaname.c_str();
    }
    else if (*pstr++ != '/') {
      return 0;
    }
  }
  else {
    return 0;
  }

  return (!strncmp (pstr, fqn, strlen (fqn)) &&
          (!*fqn || pstr[strlen(fqn)] == '/'));
}

char *
MICOPOA::POAObjectReference::next_descendant_poa (const char * fqn,
                                                  const char * implname)
{
  bool r = decompose_ref ();
  ((void) ((r) ? 0 : (__assert_fail ("r", "poa_impl.cc", 840, __PRETTY_FUNCTION__), 0)));
  ((void) ((in_descendant_poa (fqn, implname)) ? 0 : (__assert_fail ("in_descendant_poa (fqn, implname)", "poa_impl.cc", 841, __PRETTY_FUNCTION__), 0)));

  const char * pstr = poaname.c_str();

  if (*implname && strncmp (pstr, implname, strlen (implname)) == 0) {
    pstr += strlen (implname);
    if (!*pstr) {
      pstr = poaname.c_str();
    }
    else {
      ((void) ((*pstr == '/') ? 0 : (__assert_fail ("*pstr == '/'", "poa_impl.cc", 851, __PRETTY_FUNCTION__), 0)));
      pstr++;
    }
  }
  else {
    ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 856, __PRETTY_FUNCTION__), 0)));
  }

  size_t i, j;
  char * res;

  if (*fqn) {
    pstr += strlen (fqn);
    ((void) ((*pstr == '/') ? 0 : (__assert_fail ("*pstr == '/'", "poa_impl.cc", 864, __PRETTY_FUNCTION__), 0)));
    pstr++;
  }

  for (i=0, j=0; pstr[i] && pstr[i] != '/'; i++, j++) {
    if (pstr[i] == '\\') {
      i++;
    }
  }

  res = CORBA::string_alloc (i);
  ((void) ((res) ? 0 : (__assert_fail ("res", "poa_impl.cc", 875, __PRETTY_FUNCTION__), 0)));

  for (i=0, j=0; pstr[i] && pstr[i] != '/'; i++, j++) {
    if (pstr[i] == '\\') {
      i++;
    }
    res[j] = pstr[i];
  }

  res[j] = '\0';
  return res;
}





MICOPOA::UniqueIdGenerator::UniqueIdGenerator ()
{
  uid = __null;
  prefix = __null;
  pfxlen = 0;
}

MICOPOA::UniqueIdGenerator::UniqueIdGenerator (const char * pfx)
{
  uid = __null;
  prefix = CORBA::string_dup (pfx);
  pfxlen = strlen (prefix);
}

MICOPOA::UniqueIdGenerator::~UniqueIdGenerator ()
{
  CORBA::string_free (uid);
  CORBA::string_free (prefix);
}

char *
MICOPOA::UniqueIdGenerator::new_id ()
{
  char * id;





  if (uid == __null) {
    ulen = 1;
    uid = CORBA::string_alloc (ulen);
    ((void) ((uid) ? 0 : (__assert_fail ("uid", "poa_impl.cc", 924, __PRETTY_FUNCTION__), 0)));
    uid[0] = '0';
    uid[1] = 0;
  }
  else {
    int i;
    for (i=0; i<ulen; i++) {
      if (uid[i] != '9')
        break;
      uid[i] = '0';
    }
    if (i == ulen) {
      CORBA::string_free (uid);
      uid = CORBA::string_alloc (++ulen);
      ((void) ((uid) ? 0 : (__assert_fail ("uid", "poa_impl.cc", 938, __PRETTY_FUNCTION__), 0)));
      for (i=0; i<ulen-1; i++) {
        uid[i] = '0';
      }
      uid[ulen-1] = '1';
      uid[ulen] = 0;
    }
    else {
      uid[i] = uid[i] + 1;
    }
  }
  id = CORBA::string_alloc (ulen + pfxlen);
  ((void) ((id) ? 0 : (__assert_fail ("id", "poa_impl.cc", 950, __PRETTY_FUNCTION__), 0)));
  if (prefix) strcpy (id, prefix);
  strcpy (id+pfxlen, uid);

  return id;
}

char *
MICOPOA::UniqueIdGenerator::state ()
{
  char * res;

  if (uid == __null && prefix == __null) {
    res = CORBA::string_alloc (0);
    res[0] = 0;
    return res;
  }

  if (uid == __null) {
    res = CORBA::string_alloc (pfxlen + 1);
    strcpy (res+1, prefix);
    res[0] = ':';
    return res;
  }

  res = CORBA::string_alloc (ulen + pfxlen + 1);
  strcpy (res, uid);
  if (prefix) strcpy (res+ulen+1, prefix);
  res[ulen] = ':';
  return res;
}

void
MICOPOA::UniqueIdGenerator::state (const char * st)
{
  CORBA::string_free (uid);
  CORBA::string_free (prefix);

  if (!*st) {
    uid = __null;
    prefix = __null;
  }

  if (*st == ':') {
    uid = __null;
    pfxlen = strlen (st+1);
    prefix = CORBA::string_dup (st+1);
  }

  for (ulen=0; st[ulen] && st[ulen] != ':'; ulen++);
  ((void) ((st[ulen] == ':') ? 0 : (__assert_fail ("st[ulen] == ':'", "poa_impl.cc", 1000, __PRETTY_FUNCTION__), 0)));
  uid = CORBA::string_alloc (ulen);
  for (int i=0; i<ulen; i++) {
    uid[i] = st[i];
  }
  uid[ulen] = 0;
  pfxlen = strlen (st+ulen+1);
  prefix = CORBA::string_dup (st+ulen+1);
}





MICOPOA::ObjectMap::ObjectRecord::ObjectRecord (POAObjectReference * _por,
                                                PortableServer::Servant _serv)
  : por (_por), serv (_serv)
{
  por = _por;
  serv = _serv;
  serv->_add_ref ();
}

MICOPOA::ObjectMap::ObjectRecord::~ObjectRecord ()
{
  delete por;
  serv->_remove_ref ();
}

MICOPOA::ObjectMap::~ObjectMap ()
{
  clear ();
}

bool
MICOPOA::ObjectMap::empty () const
{
  return objs.empty ();
}

void
MICOPOA::ObjectMap::clear ()
{
  iterator it = objs.begin ();

  while (it != objs.end()) {
    delete (*it).second;
    it++;
  }

  objs.clear ();
  servants.clear ();
}

MICOPOA::ObjectMap::iterator
MICOPOA::ObjectMap::begin ()
{
  return objs.begin ();
}

MICOPOA::ObjectMap::iterator
MICOPOA::ObjectMap::end ()
{
  return objs.end ();
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::pop ()
{
  ((void) ((!empty()) ? 0 : (__assert_fail ("!empty()", "poa_impl.cc", 1069, __PRETTY_FUNCTION__), 0)));
  iterator oit = objs.begin ();
  ObjectRecord * orec = (*oit).second;
  objs.erase (oit);

  SvMap::iterator sit = servants.find (orec->serv);
  ((void) ((sit != servants.end()) ? 0 : (__assert_fail ("sit != servants.end()", "poa_impl.cc", 1075, __PRETTY_FUNCTION__), 0)));

  for (vector<ObjectRecord *>::iterator orit = (*sit).second.begin();
       orit != (*sit).second.end(); orit++) {
    if ((*orit) == orec) {
      (*sit).second.erase (orit);
      break;
    }
  }

  if ((*sit).second.empty()) {
    servants.erase (sit);
  }

  return orec;
}

void
MICOPOA::ObjectMap::add (POAObjectReference * por,
                         PortableServer::Servant serv)
{
  ObjectRecord * orec = new ObjectRecord (por, serv);
  ObjectId oid (por->get_id());
  ((void) ((objs.find (oid) == objs.end()) ? 0 : (__assert_fail ("objs.find (oid) == objs.end()", "poa_impl.cc", 1098, __PRETTY_FUNCTION__), 0)));

  objs[oid] = orec;
  servants[serv].push_back (orec);
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::del (const ObjectId & oid)
{
  iterator it = objs.find (oid);
  ((void) ((it != objs.end()) ? 0 : (__assert_fail ("it != objs.end()", "poa_impl.cc", 1108, __PRETTY_FUNCTION__), 0)));
  ObjectRecord * orec = (*it).second;
  SvMap::iterator sit = servants.find (orec->serv);
  ((void) ((sit != servants.end()) ? 0 : (__assert_fail ("sit != servants.end()", "poa_impl.cc", 1111, __PRETTY_FUNCTION__), 0)));

  for (vector<ObjectRecord *>::iterator orit = (*sit).second.begin();
       orit != (*sit).second.end(); orit++) {
    if ((*orit) == orec) {
      (*sit).second.erase (orit);
      break;
    }
  }

  if ((*sit).second.empty()) {
    servants.erase (sit);
  }

  objs.erase (it);
  return orec;
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::del (const PortableServer::ObjectId & id)
{
  return del (ObjectId (id));
}

bool
MICOPOA::ObjectMap::exists (const ObjectId & oid)
{
  return (objs.find (oid) != objs.end());
}

bool
MICOPOA::ObjectMap::exists (const PortableServer::ObjectId & id)
{
  return exists (ObjectId (id));
}

bool
MICOPOA::ObjectMap::exists (const POAObjectReference & por)
{

  POAObjectReference * nc = (POAObjectReference *) &por;
  return (objs.find (nc->get_oid()) != objs.end());
}

bool
MICOPOA::ObjectMap::exists (PortableServer::Servant serv)
{
  SvMap::iterator sit = servants.find (serv);
  ((void) ((sit==servants.end() || !(*sit).second.empty()) ? 0 : (__assert_fail ("sit==servants.end() || !(*sit).second.empty()", "poa_impl.cc", 1159, __PRETTY_FUNCTION__), 0)));
  return (sit != servants.end());
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::find (const ObjectId & oid)
{
  iterator it = objs.find (oid);
  if (it == objs.end()) {
    return __null;
  }
  return (*it).second;
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::find (const PortableServer::ObjectId & id)
{
  return find (ObjectId (id));
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::find (const POAObjectReference & por)
{

  POAObjectReference * nc = (POAObjectReference *) &por;
  return find (nc->get_oid());
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::find (POA_impl * poa, CORBA::Object_ptr obj)
{
  if (CORBA::is_nil (obj) || !obj->_ior() || !obj->_ior()->profile()) {
    return __null;
  }

  CORBA::Long length, i;
  const CORBA::Octet * key = obj->_ior()->profile()->objectkey (length);

  if (!key) {
    return __null;
  }
# 1209 "poa_impl.cc"
  for (i=length-1; i>0; i--) {
    if (key[i] == '/') {
      break;
    }
  }

  if (i==0 || key[i++-1] != '\\') {
    return find (ObjectId ((const char *) key+i,
                           (CORBA::ULong) length-i,
                           0));
  }

  return find (POAObjectReference (poa, obj));
}

MICOPOA::ObjectMap::ObjectRecord *
MICOPOA::ObjectMap::find (PortableServer::Servant serv)
{
  SvMap::iterator sit = servants.find (serv);
  if (sit == servants.end()) {
    return __null;
  }
  ((void) (((*sit).second.size() == 1) ? 0 : (__assert_fail ("(*sit).second.size() == 1", "poa_impl.cc", 1231, __PRETTY_FUNCTION__), 0)));
  return (*sit).second[0];
}
# 1243 "poa_impl.cc"
MICOPOA::POA_impl::InvocationRecord::InvocationRecord (CORBA::ORB::MsgId _id,
                                                       POAObjectReference * _por,
                                                       CORBA::ORBRequest * _req,
                                                       CORBA::Principal_ptr _pr)
  : msgid (_id)
{
  por = new POAObjectReference (*_por);
  req = CORBA::ORBRequest::_duplicate (_req);
  pr = CORBA::Principal::_duplicate (_pr);
  svr = CORBA::ServerRequest::_nil ();
}

MICOPOA::POA_impl::InvocationRecord::~InvocationRecord ()
{
  CORBA::release (req);
  CORBA::release (pr);
  CORBA::release (svr);
  delete por;
}

void
MICOPOA::POA_impl::InvocationRecord::exec (POA_impl * poa)
{
  poa->local_invoke (this);
}

CORBA::ORB::MsgId
MICOPOA::POA_impl::InvocationRecord::id ()
{
  return msgid;
}

CORBA::ORBRequest *
MICOPOA::POA_impl::InvocationRecord::get_or ()
{
  return req;
}

MICOPOA::POAObjectReference *
MICOPOA::POA_impl::InvocationRecord::get_por ()
{
  return por;
}

CORBA::ServerRequestBase_ptr
MICOPOA::POA_impl::InvocationRecord::make_req (POA_impl * poa,
                                               PortableServer::Servant serv)
{
  ((void) ((serv) ? 0 : (__assert_fail ("serv", "poa_impl.cc", 1291, __PRETTY_FUNCTION__), 0)));
  ((void) ((CORBA::is_nil (svr)) ? 0 : (__assert_fail ("CORBA::is_nil (svr)", "poa_impl.cc", 1292, __PRETTY_FUNCTION__), 0)));
  if (CORBA::is_nil (svr)) {
    svr = serv->make_request (req, por->get_ref(), msgid, poa, pr);
    ((void) ((!CORBA::is_nil (svr)) ? 0 : (__assert_fail ("!CORBA::is_nil (svr)", "poa_impl.cc", 1295, __PRETTY_FUNCTION__), 0)));
  }
  return svr;
}

CORBA::ServerRequest_ptr
MICOPOA::POA_impl::InvocationRecord::make_dyn_req (POA_impl * poa)
{
  CORBA::ServerRequest_ptr dynsvr;

  ((void) ((CORBA::is_nil (svr)) ? 0 : (__assert_fail ("CORBA::is_nil (svr)", "poa_impl.cc", 1305, __PRETTY_FUNCTION__), 0)));
  dynsvr = new CORBA::ServerRequest (req, por->get_ref(), msgid, poa, pr);
  svr = dynsvr;
  ((void) ((!CORBA::is_nil (svr)) ? 0 : (__assert_fail ("!CORBA::is_nil (svr)", "poa_impl.cc", 1308, __PRETTY_FUNCTION__), 0)));
  return dynsvr;
}





char *
MICOPOA::POA_impl::the_name ()
{
  return CORBA::string_dup (name.c_str());
}

PortableServer::POA_ptr
MICOPOA::POA_impl::the_parent ()
{
  return PortableServer::POA::_duplicate (parent);
}

PortableServer::POAManager_ptr
MICOPOA::POA_impl::the_POAManager ()
{
  return PortableServer::POAManager::_duplicate (manager);
}

PortableServer::POAList *
MICOPOA::POA_impl::the_children ()
{
  PortableServer::POAList * res = new PortableServer::POAList;
  POAMap::iterator it = children.begin ();
  CORBA::ULong i = 0;

  res->length (children.size());
  while (it != children.end()) {
    (*res)[i++] = PortableServer::POA::_duplicate ((*it++).second);
  }

  return res;
}

PortableServer::AdapterActivator_ptr
MICOPOA::POA_impl::the_activator ()
{
  return PortableServer::AdapterActivator::_duplicate (adapter_activator);
}

void
MICOPOA::POA_impl::the_activator (PortableServer::AdapterActivator_ptr _aa)
{
  adapter_activator = PortableServer::AdapterActivator::_duplicate (_aa);
}





PortableServer::ThreadPolicy_ptr
MICOPOA::POA_impl::create_thread_policy (PortableServer::ThreadPolicyValue _v)
{
  return new ThreadPolicy_impl (PortableServer::THREAD_POLICY_ID, _v);
}

PortableServer::LifespanPolicy_ptr
MICOPOA::POA_impl::create_lifespan_policy (PortableServer::LifespanPolicyValue _v)
{
  return new LifespanPolicy_impl (PortableServer::LIFESPAN_POLICY_ID, _v);
}

PortableServer::IdUniquenessPolicy_ptr
MICOPOA::POA_impl::create_id_uniqueness_policy (PortableServer::IdUniquenessPolicyValue _v)
{
  return new IdUniquenessPolicy_impl (PortableServer::ID_UNIQUENESS_POLICY_ID, _v);
}

PortableServer::IdAssignmentPolicy_ptr
MICOPOA::POA_impl::create_id_assignment_policy (PortableServer::IdAssignmentPolicyValue _v)
{
  return new IdAssignmentPolicy_impl (PortableServer::ID_ASSIGNMENT_POLICY_ID, _v);
}

PortableServer::ImplicitActivationPolicy_ptr
MICOPOA::POA_impl::create_implicit_activation_policy (PortableServer::ImplicitActivationPolicyValue _v)
{
  return new ImplicitActivationPolicy_impl (PortableServer::IMPLICIT_ACTIVATION_POLICY_ID, _v);
}

PortableServer::ServantRetentionPolicy_ptr
MICOPOA::POA_impl::create_servant_retention_policy (PortableServer::ServantRetentionPolicyValue _v)
{
  return new ServantRetentionPolicy_impl (PortableServer::SERVANT_RETENTION_POLICY_ID, _v);
}

PortableServer::RequestProcessingPolicy_ptr
MICOPOA::POA_impl::create_request_processing_policy (PortableServer::RequestProcessingPolicyValue _v)
{
  return new RequestProcessingPolicy_impl (PortableServer::REQUEST_PROCESSING_POLICY_ID, _v);
}





PortableServer::ServantManager_ptr
MICOPOA::POA_impl::get_servant_manager ()
{
  if (request_processing_policy->value () != PortableServer::USE_SERVANT_MANAGER) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  return PortableServer::ServantManager::_duplicate (servant_manager);
}

void
MICOPOA::POA_impl::set_servant_manager (PortableServer::ServantManager_ptr _s)
{
  if (request_processing_policy->value () != PortableServer::USE_SERVANT_MANAGER) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  if (CORBA::is_nil (_s)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  if ((servant_retention_policy->value() == PortableServer::RETAIN &&
       !_s->_is_a ("IDL:omg.org/PortableServer/ServantActivator:1.0")) ||
      (servant_retention_policy->value() == PortableServer::NON_RETAIN &&
       !_s->_is_a ("IDL:omg.org/PortableServer/ServantLocator:1.0"))) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  if (!CORBA::is_nil (servant_manager)) {
    mico_throw (CORBA::BAD_INV_ORDER (0, CORBA::COMPLETED_NO));
  }

  servant_manager = PortableServer::ServantManager::_duplicate (_s);
}

PortableServer::Servant
MICOPOA::POA_impl::get_servant ()
{
  if (request_processing_policy->value () != PortableServer::USE_DEFAULT_SERVANT) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  if (default_servant == __null) {
    mico_throw (PortableServer::POA::NoServant());
  }

  default_servant->_add_ref ();
  return default_servant;
}

void
MICOPOA::POA_impl::set_servant (PortableServer::Servant _s)
{
  if (request_processing_policy->value () != PortableServer::USE_DEFAULT_SERVANT) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  if (default_servant) {
    default_servant->_remove_ref ();
  }

  _s->_add_ref ();
  default_servant = _s;
}





void
MICOPOA::POA_impl::set_policies (const CORBA::PolicyList & policies)
{
  thread_policy = PortableServer::ThreadPolicy::_nil();
  lifespan_policy = PortableServer::LifespanPolicy::_nil();
  id_uniqueness_policy = PortableServer::IdUniquenessPolicy::_nil();
  id_assignment_policy = PortableServer::IdAssignmentPolicy::_nil();
  implicit_activation_policy =
    PortableServer::ImplicitActivationPolicy::_nil();
  servant_retention_policy = PortableServer::ServantRetentionPolicy::_nil();
  request_processing_policy = PortableServer::RequestProcessingPolicy::_nil();

  for (CORBA::ULong i=0; i<policies.length(); i++) {
    CORBA::Policy_ptr pol = policies[i].in();

    if (pol->policy_type() == PortableServer::THREAD_POLICY_ID) {
      thread_policy = PortableServer::ThreadPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (thread_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (thread_policy)", "poa_impl.cc", 1497, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::LIFESPAN_POLICY_ID) {
      lifespan_policy = PortableServer::LifespanPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (lifespan_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (lifespan_policy)", "poa_impl.cc", 1501, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::ID_UNIQUENESS_POLICY_ID) {
      id_uniqueness_policy =
        PortableServer::IdUniquenessPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (id_uniqueness_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (id_uniqueness_policy)", "poa_impl.cc", 1506, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::ID_ASSIGNMENT_POLICY_ID) {
      id_assignment_policy =
        PortableServer::IdAssignmentPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (id_assignment_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (id_assignment_policy)", "poa_impl.cc", 1511, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::IMPLICIT_ACTIVATION_POLICY_ID) {
      implicit_activation_policy =
        PortableServer::ImplicitActivationPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (implicit_activation_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (implicit_activation_policy)", "poa_impl.cc", 1516, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::SERVANT_RETENTION_POLICY_ID) {
      servant_retention_policy =
        PortableServer::ServantRetentionPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (servant_retention_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (servant_retention_policy)", "poa_impl.cc", 1521, __PRETTY_FUNCTION__), 0)));
    }
    else if (pol->policy_type() == PortableServer::REQUEST_PROCESSING_POLICY_ID) {
      request_processing_policy =
        PortableServer::RequestProcessingPolicy::_narrow (pol);
      ((void) ((!CORBA::is_nil (request_processing_policy)) ? 0 : (__assert_fail ("!CORBA::is_nil (request_processing_policy)", "poa_impl.cc", 1526, __PRETTY_FUNCTION__), 0)));
    }
    else {
      PortableServer::POA::InvalidPolicy ex;
      ex.index = i;
      mico_throw (ex);
    }
  }





  if (CORBA::is_nil (thread_policy)) {
    thread_policy = create_thread_policy (PortableServer::ORB_CTRL_MODEL);
  }

  if (CORBA::is_nil (lifespan_policy)) {
    lifespan_policy = create_lifespan_policy (PortableServer::TRANSIENT);
  }

  if (CORBA::is_nil (id_uniqueness_policy)) {
    id_uniqueness_policy =
      create_id_uniqueness_policy (PortableServer::UNIQUE_ID);
  }

  if (CORBA::is_nil (id_assignment_policy)) {
    id_assignment_policy =
      create_id_assignment_policy (PortableServer::SYSTEM_ID);
  }

  if (CORBA::is_nil (implicit_activation_policy)) {
    implicit_activation_policy =
      create_implicit_activation_policy (PortableServer::NO_IMPLICIT_ACTIVATION);
  }

  if (CORBA::is_nil (servant_retention_policy)) {
    servant_retention_policy =
      create_servant_retention_policy (PortableServer::RETAIN);
  }

  if (CORBA::is_nil (request_processing_policy)) {
    request_processing_policy =
      create_request_processing_policy (PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);
  }
}

void
MICOPOA::POA_impl::register_child (const char * cname, POA_impl * thechild)
{
  ((void) ((children.find(cname) == children.end()) ? 0 : (__assert_fail ("children.find(cname) == children.end()", "poa_impl.cc", 1576, __PRETTY_FUNCTION__), 0)));
  (void) PortableServer::POA::_duplicate (thechild);
  children[cname] = thechild;
}

void
MICOPOA::POA_impl::unregister_child (const char * cname)
{
  POAMap::iterator it = children.find (cname);
  ((void) ((it != children.end()) ? 0 : (__assert_fail ("it != children.end()", "poa_impl.cc", 1585, __PRETTY_FUNCTION__), 0)));
  POA_impl * thechild = (*it).second;
  children.erase (it);
  CORBA::release (thechild);
}

void
MICOPOA::POA_impl::register_poa (const char * pname, POA_impl * thechild)
{
  ((void) ((AllPOAs.find(pname) == AllPOAs.end()) ? 0 : (__assert_fail ("AllPOAs.find(pname) == AllPOAs.end()", "poa_impl.cc", 1594, __PRETTY_FUNCTION__), 0)));
  AllPOAs[pname] = thechild;
}

void
MICOPOA::POA_impl::unregister_poa (const char * pname)
{
  POAMap::iterator it = AllPOAs.find (pname);
  ((void) ((it != AllPOAs.end()) ? 0 : (__assert_fail ("it != AllPOAs.end()", "poa_impl.cc", 1602, __PRETTY_FUNCTION__), 0)));
  AllPOAs.erase (it);
}

void
MICOPOA::POA_impl::etherealize ()
{





  PortableServer::ServantActivator_var sav;

  if (servant_retention_policy->value() == PortableServer::RETAIN &&
      request_processing_policy->value() == PortableServer::USE_SERVANT_MANAGER) {
    sav = PortableServer::ServantActivator::_narrow (servant_manager);
  }

  while (!ActiveObjectMap.empty()) {
    ObjectMap::ObjectRecord * orec = ActiveObjectMap.pop ();

    if (!CORBA::is_nil (sav)) {
      PortableServer::Servant serv = orec->serv;
      POAObjectReference * por = orec->por;
      orec->por = __null;
      delete orec;

      CORBA::Boolean other = ActiveObjectMap.exists (serv);

      try {

        sav->etherealize (por->get_id(), this, serv, 1, other);

      } catch (CORBA::SystemException_catch &) {

      }

      delete por;
    }
    else {
      delete orec;
    }
  }
}





MICOPOA::POA_impl::POA_impl (const char * _name,
                             PortableServer::POAManager_ptr _manager,
                             const CORBA::PolicyList & policies,
                             POA_impl * _parent,
                             CORBA::ORB_ptr _orb)
  : name (_name), parent(_parent), orb(_orb)
{
  destructed = 0;
  unique_id = 0;
  set_policies (policies);





  (void) PortableServer::POA::_duplicate (this);






  if (!CORBA::is_nil (_manager)) {
    manager = PortableServer::POAManager::_duplicate (_manager);
  }
  else {
    manager = new POAManager_impl ();
  }

  ((void) ((!CORBA::is_nil (orb)) ? 0 : (__assert_fail ("!CORBA::is_nil (orb)", "poa_impl.cc", 1681, __PRETTY_FUNCTION__), 0)));
  ((void) ((parent) ? 0 : (__assert_fail ("parent", "poa_impl.cc", 1682, __PRETTY_FUNCTION__), 0)));
  ((void) ((!CORBA::is_nil (manager)) ? 0 : (__assert_fail ("!CORBA::is_nil (manager)", "poa_impl.cc", 1683, __PRETTY_FUNCTION__), 0)));

  default_servant = __null;
  servant_manager = PortableServer::ServantManager::_nil ();
  adapter_activator = PortableServer::AdapterActivator::_nil ();

  if (parent->fqn.length() > 0) {
    fqn = parent->fqn + "/";
  }

  const char * nptr = name.c_str ();

  while (*nptr) {
    if (*nptr == '/' || *nptr == '\\') {
      fqn += '\\';
    }
    fqn += *nptr++;
  }

  state = manager->get_state ();
# 1720 "poa_impl.cc"
  if (lifespan_policy->value() == PortableServer::TRANSIENT) {
    CORBA::String_var uid = poauid.new_id ();
    oaid = oaprefix;
    oaid += "/";
    oaid += uid.in();
  }
  else {




    if (impl_name.size() == 0) {
      PortableServer::POA::InvalidPolicy ex;
      for (CORBA::UShort j=0; j<policies.length(); j++) {
        CORBA::Policy_var p1 = policies[j];
        PortableServer::LifespanPolicy_var p2 =
          PortableServer::LifespanPolicy::_narrow (p1);
        if (!CORBA::is_nil (p2) && p2->value() == PortableServer::PERSISTENT) {
          ex.index = j;
          break;
        }
      }
      mico_throw (ex);
    }

    ((void) ((impl_name.size() > 0) ? 0 : (__assert_fail ("impl_name.size() > 0", "poa_impl.cc", 1745, __PRETTY_FUNCTION__), 0)));





    if (impl_name == fqn && fqn.find ('/') == (size_t) -1) {
      oaid = fqn;
    }
    else {
      const char * inptr = impl_name.c_str ();

      while (*inptr) {
        if (*inptr == '/' || *inptr == '\\') {
          oaid += '\\';
        }
        oaid += *inptr++;
      }

      oaid += "/";
      oaid += fqn;
    }
  }





  register_poa (oaid.c_str(), this);
  manager->add_managed_poa (this);
  parent->register_child (name.c_str(), this);
}





MICOPOA::POA_impl::POA_impl (CORBA::ORB_ptr _orb)
  : orb (_orb)
{
  destructed = 0;
  unique_id = 0;





  (void) PortableServer::POA::_duplicate (this);






  CORBA::PolicyList policies (1);
  policies.length (1);
  policies[0] =
    create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION);
  set_policies (policies);

  parent = __null;
  manager = new POAManager_impl ();
  current = new POACurrent_impl (orb);

  ((void) ((!CORBA::is_nil (orb)) ? 0 : (__assert_fail ("!CORBA::is_nil (orb)", "poa_impl.cc", 1809, __PRETTY_FUNCTION__), 0)));
  ((void) ((!CORBA::is_nil (manager)) ? 0 : (__assert_fail ("!CORBA::is_nil (manager)", "poa_impl.cc", 1810, __PRETTY_FUNCTION__), 0)));
  ((void) ((current) ? 0 : (__assert_fail ("current", "poa_impl.cc", 1811, __PRETTY_FUNCTION__), 0)));

  default_servant = __null;
  servant_manager = PortableServer::ServantManager::_nil ();
  adapter_activator = PortableServer::AdapterActivator::_nil ();

  name = (const char *) "RootPOA";
  state = PortableServer::POAManager::HOLDING;






  OSMisc::TimeVal ct = OSMisc::gettime();

  oaprefix = "/";
  oaprefix += xdec (OSMisc::getpid());
  oaprefix += "/";
  oaprefix += xdec (ct.tv_sec);







  oaid = oaprefix;





  if (poaopts["-POAImplName"] != __null) {
    impl_name = poaopts["-POAImplName"];
  }





  poamed = CORBA::POAMediator::_nil();
  ever_been_active = 0;

  if (poaopts["-POAImplName"] != __null) {
    CORBA::Object_var obj = CORBA::Object::_nil();
    if (poaopts["-POARemoteIOR"] != __null) {
        obj = orb->string_to_object (poaopts["-POARemoteIOR"]);
        ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 1859, __PRETTY_FUNCTION__), 0)));
    } else if (poaopts["-POARemoteAddr"] != __null) {
      obj = orb->bind ("IDL:omg.org/CORBA/POAMediator:1.0",
                       poaopts["-POARemoteAddr"]);
      ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 1863, __PRETTY_FUNCTION__), 0)));
    }
    if (!CORBA::is_nil (obj)) {
      poamed = CORBA::POAMediator::_narrow (obj);
      ((void) ((!CORBA::is_nil (poamed)) ? 0 : (__assert_fail ("!CORBA::is_nil (poamed)", "poa_impl.cc", 1867, __PRETTY_FUNCTION__), 0)));
    }
    if (!CORBA::is_nil (poamed)) {




      string myref = orb->ior_template()->stringify();
      CORBA::String_var poamed_ref =
        poamed->create_impl (impl_name.c_str(), myref.c_str());
      poamed_ior = CORBA::IOR (poamed_ref);
    }
  }





  PortableServer::_the_root_poa = this;





  register_poa (oaid.c_str(), this);
  manager->add_managed_poa (this);





  orb->set_initial_reference ("RootPOA", this);
  orb->register_oa (this);
}

MICOPOA::POA_impl::~POA_impl ()
{
  destroy (0, 0);
  ((void) ((children.empty()) ? 0 : (__assert_fail ("children.empty()", "poa_impl.cc", 1905, __PRETTY_FUNCTION__), 0)));
  ((void) ((InvocationQueue.empty()) ? 0 : (__assert_fail ("InvocationQueue.empty()", "poa_impl.cc", 1906, __PRETTY_FUNCTION__), 0)));

  if (PortableServer::_the_root_poa == this) {
    PortableServer::_the_root_poa = PortableServer::POA::_nil ();
    CORBA::release (current);
  }

  CORBA::release (manager);
}

PortableServer::POA_ptr
MICOPOA::POA_impl::create_POA (const char * cname,
                               PortableServer::POAManager_ptr theManager,
                               const CORBA::PolicyList & policies)
{
  if (children.find (cname) != children.end()) {
    mico_throw (PortableServer::POA::AdapterAlreadyExists());
  }

  PortableServer::POA_ptr child = new POA_impl (cname, theManager,
                                                policies, this, orb);
  ((void) ((!CORBA::is_nil (child)) ? 0 : (__assert_fail ("!CORBA::is_nil (child)", "poa_impl.cc", 1927, __PRETTY_FUNCTION__), 0)));
  return child;
}

MICOPOA::POA_impl *
MICOPOA::POA_impl::_find_POA (const char * cname,
                              CORBA::Boolean activate_it)
{
  POAMap::iterator it = children.find (cname);

  if (it != children.end()) {
    return (*it).second;
  }

  if (!activate_it || CORBA::is_nil (adapter_activator)) {
    return __null;
  }





  if (state != PortableServer::POAManager::ACTIVE) {
    return __null;
  }

  if (!adapter_activator->unknown_adapter (this, cname)) {
    return __null;
  }





  if ((it = children.find (cname)) != children.end()) {
    return (*it).second;
  }

  return __null;
}


PortableServer::POA_ptr
MICOPOA::POA_impl::find_POA (const char * cname,
                             CORBA::Boolean activate_it)
{
  POA_impl * child;


  try {

    child = _find_POA (cname, activate_it);

  } catch (CORBA::SystemException_catch & sex) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }


  if (!child) {
    mico_throw (PortableServer::POA::AdapterNonExistent());
  }

  return PortableServer::POA::_duplicate (child);
}

void
MICOPOA::POA_impl::destroy (CORBA::Boolean etherealize_objects,
                            CORBA::Boolean wait_for_completion)
{
  if (destructed) {
    return;
  }

  destructed = 1;





  unregister_poa (oaid.c_str());

  if (parent) {
    parent->unregister_child (name.c_str());
  }

  manager->del_managed_poa (this);





  while (!children.empty()) {
    POAMap::iterator it = children.begin ();
    PortableServer::POA_ptr child = (*it).second;
    child->destroy (etherealize_objects, wait_for_completion);
  }





  if (!parent) {
    if (!CORBA::is_nil (poamed)) {
      poamed->deactivate_impl (impl_name.c_str());
    }
  }





  if (!parent) {
    orb->unregister_oa (this);
  }







  state = PortableServer::POAManager::INACTIVE;

  while (!InvocationQueue.empty()) {
    InvocationRecord_ptr ir = InvocationQueue.front();
    InvocationQueue.erase (InvocationQueue.begin());
    ir->exec (this);
    CORBA::release (ir);
  }





  if (etherealize_objects) {
    etherealize ();
  }

  if (default_servant) {
    default_servant->_remove_ref ();
  }





  ActiveObjectMap.clear ();





  CORBA::release (this);
}





void
MICOPOA::POA_impl::poa_manager_callback (PortableServer::POAManager::State s,
                                         CORBA::Boolean etherealize_objects,
                                         CORBA::Boolean wait_for_completion)
{
  state = s;







  if (state == PortableServer::POAManager::ACTIVE &&
      !ever_been_active && !CORBA::is_nil (poamed)) {
    ever_been_active = 1;
    poamed->activate_impl (impl_name.c_str());
  }





  switch (state) {
  case PortableServer::POAManager::HOLDING:



    break;

  case PortableServer::POAManager::ACTIVE:



    while (!InvocationQueue.empty()) {
      InvocationRecord_ptr ir = InvocationQueue.front();
      InvocationQueue.erase (InvocationQueue.begin());
      ir->exec (this);
      CORBA::release (ir);
    }
    break;

  case PortableServer::POAManager::INACTIVE:




    if (etherealize_objects) {
      etherealize ();
    }
    break;

  case PortableServer::POAManager::DISCARDING:



    while (!InvocationQueue.empty()) {
      InvocationRecord_ptr ir = InvocationQueue.front();
      InvocationQueue.erase (InvocationQueue.begin());
      ir->exec (this);
      CORBA::release (ir);
    }
    break;

  default:
    ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 2151, __PRETTY_FUNCTION__), 0)));
  }
}
# 2162 "poa_impl.cc"
CORBA::IOR *
MICOPOA::POA_impl::ior_template ()
{
  if (lifespan_policy->value() == PortableServer::PERSISTENT) {
    if (!CORBA::is_nil (poamed)) {
      return &poamed_ior;
    }
  }

  return orb->ior_template();
}





PortableServer::ObjectId *
MICOPOA::POA_impl::activate_object (PortableServer::Servant servant)
{
  ((void) ((servant) ? 0 : (__assert_fail ("servant", "poa_impl.cc", 2181, __PRETTY_FUNCTION__), 0)));





  if (id_assignment_policy->value() != PortableServer::SYSTEM_ID ||
      servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  if (id_uniqueness_policy->value() != PortableServer::MULTIPLE_ID) {
    if (ActiveObjectMap.exists (servant)) {
      mico_throw (PortableServer::POA::ServantAlreadyActive());
    }
  }
# 2209 "poa_impl.cc"
  CORBA::String_var uid = idfactory.new_id ();
  string fulluid;

  if (lifespan_policy->value() == PortableServer::PERSISTENT) {
    fulluid = oaprefix;
  }
  fulluid += uid.in();

  PortableServer::ObjectId * id =
    PortableServer::string_to_ObjectId (fulluid.c_str());
  CORBA::String_var iface = servant->_primary_interface (*id, this);
  POAObjectReference * por = new POAObjectReference (this, *id, iface,
                                                     servant);





  servant->_activated_in (this);





  ActiveObjectMap.add (por, servant);
  return id;
}

void
MICOPOA::POA_impl::activate_object_with_id (const PortableServer::ObjectId & id,
                                            PortableServer::Servant servant)
{
  ((void) ((servant) ? 0 : (__assert_fail ("servant", "poa_impl.cc", 2241, __PRETTY_FUNCTION__), 0)));





  if (servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  if (ActiveObjectMap.exists (id)) {
    mico_throw (PortableServer::POA::ObjectAlreadyActive());
  }

  if (id_uniqueness_policy->value() != PortableServer::MULTIPLE_ID) {
    if (ActiveObjectMap.exists (servant)) {
      mico_throw (PortableServer::POA::ServantAlreadyActive());
    }
  }





  CORBA::String_var iface = servant->_primary_interface (id, this);
  POAObjectReference * por = new POAObjectReference (this, id, iface,
                                                     servant);





  servant->_activated_in (this);





  ActiveObjectMap.add (por, servant);
}

void
MICOPOA::POA_impl::deactivate_object (const PortableServer::ObjectId & id)
{




  if (servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  if (!ActiveObjectMap.exists (id)) {
    mico_throw (PortableServer::POA::ObjectNotActive());
  }

  ObjectMap::ObjectRecord * orec = ActiveObjectMap.del (id);
  CORBA::Boolean other = ActiveObjectMap.exists (orec->serv);





  if (!CORBA::is_nil (servant_manager)) {
    PortableServer::ServantActivator_var sav =
      PortableServer::ServantActivator::_narrow (servant_manager);
    ((void) ((!CORBA::is_nil (sav)) ? 0 : (__assert_fail ("!CORBA::is_nil (sav)", "poa_impl.cc", 2311, __PRETTY_FUNCTION__), 0)));

    PortableServer::Servant serv = orec->serv;
    POAObjectReference * por = orec->por;
    orec->por = __null;
    delete orec;

    sav->etherealize (por->get_id(), this, serv, 0, other);
    delete por;
  }
  else {
    delete orec;
  }
}

CORBA::Object_ptr
MICOPOA::POA_impl::create_reference (const char * repoid)
{
  ((void) ((repoid) ? 0 : (__assert_fail ("repoid", "poa_impl.cc", 2329, __PRETTY_FUNCTION__), 0)));





  if (id_assignment_policy->value() != PortableServer::SYSTEM_ID) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  CORBA::String_var uid = idfactory.new_id ();
  string fulluid;

  if (lifespan_policy->value() == PortableServer::PERSISTENT) {
    fulluid = oaprefix;
  }
  fulluid += uid.in();

  PortableServer::ObjectId_var id =
    PortableServer::string_to_ObjectId (fulluid.c_str());
  POAObjectReference * por = new POAObjectReference (this, id.in(), repoid);
  CORBA::Object_ptr obj = por->ref();
  ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 2351, __PRETTY_FUNCTION__), 0)));
  delete por;
  return obj;
}

CORBA::Object_ptr
MICOPOA::POA_impl::create_reference_with_id (const PortableServer::ObjectId & id,
                                             const char * repoid)
{
  ((void) ((repoid) ? 0 : (__assert_fail ("repoid", "poa_impl.cc", 2360, __PRETTY_FUNCTION__), 0)));

  POAObjectReference * por = new POAObjectReference (this, id, repoid);
  CORBA::Object_ptr obj = por->ref();
  ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 2364, __PRETTY_FUNCTION__), 0)));
  delete por;
  return obj;
}





CORBA::Object_ptr
MICOPOA::POA_impl::activate_for_this (PortableServer::Servant servant)
{




  if (servant_retention_policy->value() != PortableServer::RETAIN ||
      id_uniqueness_policy->value() != PortableServer::UNIQUE_ID) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (servant);





  if (!orec) {
    if (implicit_activation_policy->value() != PortableServer::IMPLICIT_ACTIVATION) {
      mico_throw (PortableServer::POA::WrongPolicy());
    }

    PortableServer::ObjectId * id = activate_object (servant);
    orec = ActiveObjectMap.find (*id);
    ((void) ((orec) ? 0 : (__assert_fail ("orec", "poa_impl.cc", 2402, __PRETTY_FUNCTION__), 0)));
    delete id;
  }

  return orec->por->ref();
}





PortableServer::ObjectId *
MICOPOA::POA_impl::servant_to_id (PortableServer::Servant servant)
{
  ((void) ((servant) ? 0 : (__assert_fail ("servant", "poa_impl.cc", 2416, __PRETTY_FUNCTION__), 0)));
# 2426 "poa_impl.cc"
  if (request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT &&
      servant == default_servant &&
      !CORBA::is_nil (PortableServer::_the_poa_current) &&
      PortableServer::_the_poa_current->iscurrent() &&
      PortableServer::_the_poa_current->get_serv() == servant) {
    return PortableServer::_the_poa_current->get_object_id ();
  }





  if (servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }






  if (implicit_activation_policy->value() == PortableServer::IMPLICIT_ACTIVATION &&
      id_uniqueness_policy->value() == PortableServer::MULTIPLE_ID) {
    return activate_object (servant);
  }





  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (servant);

  if (orec) {
    return orec->por->id();
  }





  if (implicit_activation_policy->value() == PortableServer::IMPLICIT_ACTIVATION) {
    return activate_object (servant);
  }

  mico_throw (PortableServer::POA::ServantNotActive());





  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 2476, __PRETTY_FUNCTION__), 0)));
  return __null;
}

CORBA::Object_ptr
MICOPOA::POA_impl::servant_to_reference (PortableServer::Servant servant)
{
  ((void) ((servant) ? 0 : (__assert_fail ("servant", "poa_impl.cc", 2483, __PRETTY_FUNCTION__), 0)));







  if (!CORBA::is_nil (PortableServer::_the_poa_current) &&
      PortableServer::_the_poa_current->iscurrent() &&
      PortableServer::_the_poa_current->get_serv() == servant) {
    return PortableServer::_the_poa_current->make_ref ();
  }





  if (servant_retention_policy->value() != PortableServer::RETAIN ||
      (id_uniqueness_policy->value() != PortableServer::UNIQUE_ID &&
       implicit_activation_policy->value() != PortableServer::IMPLICIT_ACTIVATION)) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }

  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (servant);






  if (implicit_activation_policy->value() == PortableServer::IMPLICIT_ACTIVATION &&
      (id_uniqueness_policy->value() == PortableServer::MULTIPLE_ID || !orec)) {
    PortableServer::ObjectId * id = activate_object (servant);
    orec = ActiveObjectMap.find (*id);
    ((void) ((orec) ? 0 : (__assert_fail ("orec", "poa_impl.cc", 2518, __PRETTY_FUNCTION__), 0)));
    delete id;
  }

  if (orec) {
    return orec->por->ref();
  }

  mico_throw (PortableServer::POA::ServantNotActive());





  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 2532, __PRETTY_FUNCTION__), 0)));
  return CORBA::Object::_nil();
}

PortableServer::Servant
MICOPOA::POA_impl::reference_to_servant (CORBA::Object_ptr obj)
{
  ((void) ((!CORBA::is_nil (obj)) ? 0 : (__assert_fail ("!CORBA::is_nil (obj)", "poa_impl.cc", 2539, __PRETTY_FUNCTION__), 0)));





  if (servant_retention_policy->value() != PortableServer::RETAIN &&
      request_processing_policy->value() != PortableServer::USE_DEFAULT_SERVANT) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  POAObjectReference por (this, obj);

  if (!por.is_legal() || !por.in_poa(oaid.c_str())) {
    mico_throw (PortableServer::POA::WrongAdapter());
  }





  if (servant_retention_policy->value() == PortableServer::RETAIN) {
    ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (por);

    if (orec) {
      orec->serv->_add_ref ();
      return orec->serv;
    }
  }





  if (request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT && default_servant) {
    default_servant->_add_ref ();
    return default_servant;
  }

  mico_throw (PortableServer::POA::ObjectNotActive());





  ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 2588, __PRETTY_FUNCTION__), 0)));
  return __null;
}

PortableServer::ObjectId *
MICOPOA::POA_impl::reference_to_id (CORBA::Object_ptr obj)
{




  POAObjectReference por (this, obj);

  if (!por.is_legal() || !por.in_poa(oaid.c_str())) {
    mico_throw (PortableServer::POA::WrongAdapter());
  }





  return por.id();
}

PortableServer::Servant
MICOPOA::POA_impl::id_to_servant (const PortableServer::ObjectId &id)
{




  if (servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (id);

  if (orec == __null) {
    mico_throw (PortableServer::POA::ObjectNotActive());
  }

  orec->serv->_add_ref ();
  return orec->serv;
}

CORBA::Object_ptr
MICOPOA::POA_impl::id_to_reference (const PortableServer::ObjectId & id)
{




  if (servant_retention_policy->value() != PortableServer::RETAIN) {
    mico_throw (PortableServer::POA::WrongPolicy());
  }





  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (id);

  if (orec == __null) {
    mico_throw (PortableServer::POA::ObjectNotActive());
  }

  return orec->por->ref();
}
# 2669 "poa_impl.cc"
PortableServer::Servant
MICOPOA::POA_impl::preinvoke (CORBA::Object_ptr obj)
{
  switch (state) {
  case PortableServer::POAManager::HOLDING:
  case PortableServer::POAManager::DISCARDING:
    mico_throw (CORBA::TRANSIENT());

  case PortableServer::POAManager::INACTIVE:
    return __null;
  }

  ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (this, obj);
  PortableServer::Servant serv;
  POAObjectReference * por;

  if (orec) {
    serv = orec->serv;
    por = orec->por;
  }
  else if (request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT && default_servant) {
    serv = default_servant;
    por = new POAObjectReference (this, obj);
  }
  else {
    return __null;
  }

  current->set (this, por, serv);
  return serv;
}

void
MICOPOA::POA_impl::postinvoke ()
{
  POAObjectReference * por = current->get_por ();
  current->unset ();
  if (request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT && default_servant) {
    delete por;
  }
}





const char *
MICOPOA::POA_impl::get_oaid () const
{
  return oaid.c_str();
}







CORBA::Boolean
MICOPOA::POA_impl::has_object (CORBA::Object_ptr obj)
{
  CORBA::Long length;
  const CORBA::Octet * key;

  if (CORBA::is_nil (obj) || !obj->_ior() || !obj->_ior()->profile()) {
    return 0;
  }

  key = obj->_ior()->profile()->objectkey (length);

  if (!key || length < 0) {
    return 0;
  }

  if (oaprefix.size() > 0 && (CORBA::ULong) length >= oaprefix.size()) {
    if (strncmp ((const char *) key, oaprefix.c_str(),
                 oaprefix.size()) == 0) {
      return 1;
    }
  }

  if (impl_name.size() > 0 && (CORBA::ULong) length >= impl_name.size()) {
    if (strncmp ((const char *) key, impl_name.c_str(),
                 impl_name.size()) == 0 &&
        (length==impl_name.size() || key[impl_name.size()] == '/')) {
      return 1;
    }
  }

  return 0;
}

CORBA::Boolean
MICOPOA::POA_impl::is_local () const
{
  return 1;
}







CORBA::Boolean
MICOPOA::POA_impl::invoke (CORBA::ORB::MsgId msgid,
                           CORBA::Object_ptr obj,
                           CORBA::ORBRequest * req,
                           CORBA::Principal_ptr pr,
                           CORBA::Boolean response_exp)
{
  ((void) ((this == PortableServer::_the_root_poa) ? 0 : (__assert_fail ("this == PortableServer::_the_root_poa", "poa_impl.cc", 2780, __PRETTY_FUNCTION__), 0)));





  POAObjectReference por (this, obj);
  ((void) ((por.is_legal()) ? 0 : (__assert_fail ("por.is_legal()", "poa_impl.cc", 2787, __PRETTY_FUNCTION__), 0)));
# 2797 "poa_impl.cc"
  if (destructed) {
    InvocationRecord_ptr ir = new InvocationRecord (msgid, &por, req, pr);
    InvocationQueue.push_back (ir);
    return 1;
  }





  POAMap::iterator it = AllPOAs.find (por.poa_name());
  POA_impl * poa;

  if (it != AllPOAs.end()) {
    poa = (*it).second;
  }
  else {






    if (impl_name.size() == 0 || *por.poa_name() == '/') {
      InvocationRecord_var ir = new InvocationRecord (msgid, &por, req, pr);
      CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
      CORBA::Exception * ex =
        new CORBA::OBJECT_NOT_EXIST (0, CORBA::COMPLETED_NO);
      svr->exception (ex);
      return 1;
    }

    CORBA::String_var cname;
    POA_impl *iter;
    poa = this;

    while (42) {
      if (por.in_poa (poa->oaid.c_str())) {
        break;
      }
      cname = por.next_descendant_poa (poa->fqn.c_str(), impl_name.c_str());

      try {

        iter = poa->_find_POA (cname, 0);

      } catch (CORBA::SystemException_catch & sex) {
        InvocationRecord_var ir = new InvocationRecord (msgid, &por, req, pr);
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (poa);
        CORBA::Exception * ex =
          new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
        svr->exception (ex);
        return 1;
      }


      if (iter == __null) {
        break;
      }

      poa = iter;
    }
  }





  InvocationRecord_var ir = new InvocationRecord (msgid, &por, req, pr);

  poa->local_invoke (ir);

  return 1;
}
# 2880 "poa_impl.cc"
void
MICOPOA::POA_impl::local_invoke (InvocationRecord_ptr ir)
{






  if ((lifespan_policy->value() == PortableServer::PERSISTENT ||
       !ir->get_por()->in_poa (oaid.c_str())) && destructed) {
    if (CORBA::is_nil (poamed)) {
      CORBA::ServerRequest_ptr svreq = ir->make_dyn_req (this);
      CORBA::Exception * ex =
        new CORBA::OBJECT_NOT_EXIST (0, CORBA::COMPLETED_NO);
      svreq->exception (ex);
    }
    else {
      CORBA::Object_var obj = ir->get_por()->ref();
      const CORBA::Octet * key;
      CORBA::Long length;
      CORBA::IOR * theior = new CORBA::IOR (poamed_ior);
      key = obj->_ior()->profile()->objectkey (length);
      theior->objectkey ((CORBA::Octet *) key, length);

      theior->objid (obj->_ior()->objid());
      CORBA::Object_var local_ref = new CORBA::Object (theior);
      orb->answer_invoke (ir->id(), CORBA::InvokeForward,
                          local_ref, ir->get_or(), 0);
    }
    return;
  }





  switch (state) {
  case PortableServer::POAManager::HOLDING:



    {
      InvocationQueue.push_back (InvocationRecord::_duplicate (ir));
      return;
    }
    break;

  case PortableServer::POAManager::DISCARDING:



    {
      CORBA::ServerRequest_ptr svreq = ir->make_dyn_req (this);
      CORBA::Exception * ex = new CORBA::TRANSIENT (0, CORBA::COMPLETED_NO);
      svreq->exception (ex);
      return;
    }
    break;

  case PortableServer::POAManager::INACTIVE:
# 2951 "poa_impl.cc"
    {
      if (lifespan_policy->value() == PortableServer::PERSISTENT ||
          !ir->get_por()->in_poa (oaid.c_str())) {
        InvocationQueue.push_back (InvocationRecord::_duplicate (ir));
      }
      else {
        CORBA::ServerRequest_ptr svreq = ir->make_dyn_req (this);
        CORBA::Exception * ex =
          new CORBA::OBJECT_NOT_EXIST (0, CORBA::COMPLETED_NO);
        svreq->exception (ex);
      }
      return;
    }
    break;

  case PortableServer::POAManager::ACTIVE:

    break;

  default:
    ((void) ((0) ? 0 : (__assert_fail ("0", "poa_impl.cc", 2971, __PRETTY_FUNCTION__), 0)));
  }






  if (!ir->get_por()->in_poa (oaid.c_str())) {
    CORBA::String_var cname =
      ir->get_por()->next_descendant_poa (fqn.c_str(), impl_name.c_str());
    POA_impl * poa = _find_POA (cname, 1);






    if (!poa) {
      perform_invoke (ir);
      return;
    }

    poa->local_invoke (ir);
    return;
  }





  perform_invoke (ir);
}





void
MICOPOA::POA_impl::builtin_is_a (InvocationRecord_ptr ir,
                                 PortableServer::Servant serv)
{
  CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
  CORBA::Boolean isa = 0, r;





  CORBA::NVList_ptr args = new CORBA::NVList (0);
  const char *repoid;

  args->add (CORBA::ARG_IN);
  args->item(0)->value()->set_type (CORBA::_tc_string);
  if (svr->params (args)) {
    r = (*args->item(0)->value() >>= repoid);
    ((void) ((r) ? 0 : (__assert_fail ("r", "poa_impl.cc", 3027, __PRETTY_FUNCTION__), 0)));


    try {

      isa = serv->_is_a (repoid);

    } catch (CORBA::SystemException_catch & sex) {
      svr->exception (sex->_clone());
      return;
    }


    CORBA::Any * res = new CORBA::Any;
    *res <<= CORBA::Any::from_boolean (isa);
    svr->result (res);
  }
}

void
MICOPOA::POA_impl::builtin_interface (InvocationRecord_ptr ir,
                                      PortableServer::Servant serv)
{
  CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
  CORBA::InterfaceDef_var ifd;
  CORBA::Boolean r;

  CORBA::NVList_ptr args = new CORBA::NVList (0);
  if (svr->params (args)) {

    try {

      ifd = serv->_get_interface ();

    } catch (CORBA::SystemException_catch & sex) {
      svr->exception (sex->_clone());
      return;
    }


    if (CORBA::is_nil (ifd)) {
      CORBA::Exception * ex =
        new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
      svr->exception (ex);
      return;
    }

    CORBA::Any *res = new CORBA::Any;
    *res <<= ifd.in();
    svr->result (res);
  }
}

void
MICOPOA::POA_impl::builtin_non_existent (InvocationRecord_ptr ir,
                                         PortableServer::Servant serv)
{
  CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
  CORBA::Boolean r, non_existent=1;

  CORBA::NVList_ptr args = new CORBA::NVList (0);
  if (svr->params (args)) {

    try {

      non_existent = serv->_non_existent ();

    } catch (CORBA::SystemException_catch & sex) {
      svr->exception (sex->_clone());
      return;
    }


    CORBA::Any * res = new CORBA::Any;
    *res <<= CORBA::Any::from_boolean (non_existent);
    svr->result (res);
  }
}

bool
MICOPOA::POA_impl::builtin_invoke (InvocationRecord_ptr ir,
                                   PortableServer::Servant serv)
{
  const char * opname = ir->get_or()->op_name();


  try {

    if (strcmp (opname, "_is_a") == 0) {
      builtin_is_a (ir, serv);
      return 1;
    }
    else if (strcmp (opname, "_interface") == 0) {
      builtin_interface (ir, serv);
      return 1;
    }
    else if (strcmp (opname, "_non_existent") == 0) {
      builtin_non_existent (ir, serv);
      return 1;
    }

    return 0;

  } catch (CORBA::SystemException_catch & sex) {
    CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
    svr->exception (sex->_clone());
  }
  return 1;

}

bool
MICOPOA::POA_impl::is_builtin (InvocationRecord_ptr ir)
{
  const char * opname = ir->get_or()->op_name();

  if (strcmp (opname, "_is_a") == 0 ||
      strcmp (opname, "_interface") == 0 ||
      strcmp (opname, "_non_existent") == 0) {
    return 1;
  }

  return 0;
}





void
MICOPOA::POA_impl::perform_invoke (InvocationRecord_ptr ir)
{
  PortableServer::Servant servant = __null;
  PortableServer::ServantLocator_var slo =
    PortableServer::ServantLocator::_nil ();
  PortableServer::ServantLocator::Cookie cookie;
  const char * opname = ir->get_or()->op_name();





  if (servant_retention_policy->value() == PortableServer::RETAIN) {
    ObjectMap::ObjectRecord * orec = ActiveObjectMap.find (*ir->get_por());

    if (orec) {
      ((void) ((orec->serv) ? 0 : (__assert_fail ("orec->serv", "poa_impl.cc", 3173, __PRETTY_FUNCTION__), 0)));
      servant = orec->serv;

      ir->get_por()->set_ref (orec->por->get_ref());
    }
  }





  if (!servant && request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT) {
    if (!default_servant) {
      CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
      CORBA::Exception * ex =
        new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
      svr->exception (ex);
    }

    servant = default_servant;
  }





  if (!servant && request_processing_policy->value() == PortableServer::USE_SERVANT_MANAGER) {






    if (servant_retention_policy->value() == PortableServer::RETAIN) {
      PortableServer::ServantActivator_var sav =
        PortableServer::ServantActivator::_narrow (servant_manager);

      if (CORBA::is_nil (sav)) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        CORBA::Exception * ex =
          new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
        svr->exception (ex);
        return;
      }


      try {

        servant = sav->incarnate (ir->get_por()->get_id(), this);

      } catch (PortableServer::ForwardRequest_catch & fwr) {
        orb->answer_invoke (ir->id(), CORBA::InvokeForward,
                            fwr->forward_reference,
                            ir->get_or(), 0);
        return;
      } catch (CORBA::SystemException_catch & sex1) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        svr->exception (sex1->_clone());
        return;
      }


      if (servant == __null) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        CORBA::Exception * ex =
          new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
        svr->exception (ex);
        return;
      }





      POAObjectReference * npor = new POAObjectReference (*ir->get_por());
      ActiveObjectMap.add (npor, servant);
    }
    else {
      slo = PortableServer::ServantLocator::_narrow (servant_manager);

      if (CORBA::is_nil (slo)) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        CORBA::Exception * ex =
          new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
        svr->exception (ex);
        return;
      }


      try {

        servant = slo->preinvoke (ir->get_por()->get_id(), this,
                                  ir->get_or()->op_name(), cookie);

      } catch (PortableServer::ForwardRequest_catch & fwr) {
        orb->answer_invoke (ir->id(), CORBA::InvokeForward,
                            fwr->forward_reference,
                            ir->get_or(), 0);
        return;
      } catch (CORBA::SystemException_catch & sex2) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        svr->exception (sex2->_clone());
        return;
      }


      if (servant == __null) {
        CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
        CORBA::Exception * ex =
          new CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO);
        svr->exception (ex);
        return;
      }
    }
  }

  if (!servant) {




    CORBA::ServerRequest_ptr svr = ir->make_dyn_req (this);
    CORBA::Exception * ex =
      new CORBA::OBJECT_NOT_EXIST (0, CORBA::COMPLETED_NO);
    svr->exception (ex);
    return;
  }

  current->set (this, ir->get_por(), servant);





  if (!builtin_invoke (ir, servant)) {
    CORBA::ServerRequestBase_ptr svr = ir->make_req (this, servant);
    servant->doinvoke (svr);
  }

  current->unset ();





  if (!CORBA::is_nil (slo)) {
    slo->postinvoke (ir->get_por()->get_id(), this,
                     ir->get_or()->op_name(), cookie,
                     servant);
  }
}

CORBA::Boolean
MICOPOA::POA_impl::bind (CORBA::ORB::MsgId msgid, const char *repoid,
                         const CORBA::ORB::ObjectTag &oid,
                         CORBA::Address *addr)
{
  if (addr && !addr->is_local()) {
    return 0;
  }





  if (servant_retention_policy->value() == PortableServer::RETAIN) {
    for (ObjectMap::iterator it = ActiveObjectMap.begin ();
         it != ActiveObjectMap.end ();
         it++) {
      ObjectMap::ObjectRecord * orec = (*it).second;






      if (!orec->serv->_is_a (repoid)) {
        CORBA::String_var pif =
          orec->serv->_primary_interface (orec->por->get_id(), this);
        if (strcmp (repoid, pif) != 0) {
          continue;
        }
      }





      if (oid.length() == 0 || oid == orec->por->get_id()) {
        orb->answer_bind (msgid, CORBA::LocateHere, orec->por->get_ref());
        return 1;
      }
    }
  }





  POAMap::iterator it = children.begin ();

  while (it != children.end()) {
    if ((*it).second->bind (msgid, repoid, oid, addr)) {
      return 1;
    }
    it++;
  }

  return 0;
}

CORBA::Boolean
MICOPOA::POA_impl::locate (CORBA::ORB::MsgId msgid, CORBA::Object_ptr obj)
{
  orb->answer_locate (msgid, CORBA::LocateHere, CORBA::Object::_nil(), 0);
  return 1;
}







CORBA::Object_ptr
MICOPOA::POA_impl::skeleton (CORBA::Object_ptr obj)
{
  ((void) ((this == PortableServer::_the_root_poa) ? 0 : (__assert_fail ("this == PortableServer::_the_root_poa", "poa_impl.cc", 3400, __PRETTY_FUNCTION__), 0)));

  POAObjectReference por (this, obj);
  ((void) ((por.is_legal()) ? 0 : (__assert_fail ("por.is_legal()", "poa_impl.cc", 3403, __PRETTY_FUNCTION__), 0)));

  POAMap::iterator it = AllPOAs.find (por.poa_name());

  if (it == AllPOAs.end()) {
    return CORBA::Object::_nil ();
  }





  POA_impl * poa = ((*it).second);
  ObjectMap::ObjectRecord * orec = poa->ActiveObjectMap.find (poa, obj);

  if (orec) {
    return orec->serv->_make_stub (poa, obj);
  }

  if (poa->request_processing_policy->value() == PortableServer::USE_DEFAULT_SERVANT && poa->default_servant) {
    return poa->default_servant->_make_stub (poa, obj);
  }

  return CORBA::Object::_nil ();
}

void
MICOPOA::POA_impl::cancel (CORBA::ORB::MsgId msgid)
{
  vector<InvocationRecord *>::iterator it = InvocationQueue.begin ();

  while (it != InvocationQueue.end()) {
    if ((*it)->id() == msgid) {
      delete *it;
      InvocationQueue.erase (it);
      return;
    }
    it++;
  }






  POAMap::iterator child = children.begin ();

  while (child != children.end()) {
    (*child).second->cancel (msgid);
    child++;
  }
}

void
MICOPOA::POA_impl::shutdown (CORBA::Boolean wait_for_completion)
{
  destroy (1, wait_for_completion);
  orb->answer_shutdown (this);
}

void
MICOPOA::POA_impl::answer_invoke (CORBA::ORB::MsgId msgid,
                                  CORBA::Object_ptr obj,
                                  CORBA::ORBRequest * oreq,
                                  CORBA::InvokeStatus stat)
{
  orb->answer_invoke (msgid, stat, CORBA::Object::_nil(), oreq, 0);
}
# 43 "orb_all.cc" 2
# 1 "dynany.cc" 1







# 1 "../include/CORBA.h" 1
# 9 "dynany.cc" 2
# 1 "../include/mico/throw.h" 1
# 10 "dynany.cc" 2
# 1 "../include/mico/template_impl.h" 1
# 11 "dynany.cc" 2
# 36 "dynany.cc"
class _Marshaller_DynamicAny_DynAny_InvalidValue : public CORBA::StaticTypeInfo {
    typedef ::DynamicAny::DynAny::InvalidValue _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller_DynamicAny_DynAny_InvalidValue::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_DynamicAny_DynAny_InvalidValue::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_DynamicAny_DynAny_InvalidValue::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_DynamicAny_DynAny_InvalidValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_DynamicAny_DynAny_InvalidValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0" );
  ec.except_end();
}

CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAny_InvalidValue;

void DynamicAny::DynAny::InvalidValue::_throwit() const
{


  throw *this;






}

const char *DynamicAny::DynAny::InvalidValue::_repoid() const
{
  return "IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0";
}

void DynamicAny::DynAny::InvalidValue::_encode( CORBA::DataEncoder &_en ) const
{
  _marshaller_DynamicAny_DynAny_InvalidValue->marshal( _en, (void*) this );
}

void DynamicAny::DynAny::InvalidValue::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "dynany.cc", 104, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *DynamicAny::DynAny::InvalidValue::_clone() const
{
  return new InvalidValue( *this );
}

DynamicAny::DynAny::InvalidValue *DynamicAny::DynAny::InvalidValue::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0" ) )
    return (InvalidValue *) _ex;
  return __null;
}

const DynamicAny::DynAny::InvalidValue *DynamicAny::DynAny::InvalidValue::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0" ) )
    return (InvalidValue *) _ex;
  return __null;
}
# 147 "dynany.cc"
class _Marshaller_DynamicAny_DynAny_TypeMismatch : public CORBA::StaticTypeInfo {
    typedef ::DynamicAny::DynAny::TypeMismatch _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller_DynamicAny_DynAny_TypeMismatch::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_DynamicAny_DynAny_TypeMismatch::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_DynamicAny_DynAny_TypeMismatch::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_DynamicAny_DynAny_TypeMismatch::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_DynamicAny_DynAny_TypeMismatch::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0" );
  ec.except_end();
}

CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAny_TypeMismatch;

void DynamicAny::DynAny::TypeMismatch::_throwit() const
{


  throw *this;






}

const char *DynamicAny::DynAny::TypeMismatch::_repoid() const
{
  return "IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0";
}

void DynamicAny::DynAny::TypeMismatch::_encode( CORBA::DataEncoder &_en ) const
{
  _marshaller_DynamicAny_DynAny_TypeMismatch->marshal( _en, (void*) this );
}

void DynamicAny::DynAny::TypeMismatch::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "dynany.cc", 215, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *DynamicAny::DynAny::TypeMismatch::_clone() const
{
  return new TypeMismatch( *this );
}

DynamicAny::DynAny::TypeMismatch *DynamicAny::DynAny::TypeMismatch::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0" ) )
    return (TypeMismatch *) _ex;
  return __null;
}

const DynamicAny::DynAny::TypeMismatch *DynamicAny::DynAny::TypeMismatch::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0" ) )
    return (TypeMismatch *) _ex;
  return __null;
}






DynamicAny::DynAny::~DynAny()
{
}

void *
DynamicAny::DynAny::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynAny:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

DynamicAny::DynAny_ptr
DynamicAny::DynAny::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynAny:1.0" )))
      return _duplicate( (DynamicAny::DynAny_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynAny_ptr
DynamicAny::DynAny::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynBasic::~DynBasic()
{
}

void *
DynamicAny::DynBasic::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynBasic:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynBasic_ptr
DynamicAny::DynBasic::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynBasic:1.0" )))
      return _duplicate( (DynamicAny::DynBasic_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynBasic_ptr
DynamicAny::DynBasic::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynFixed::~DynFixed()
{
}

void *
DynamicAny::DynFixed::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynFixed:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynFixed_ptr
DynamicAny::DynFixed::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynFixed:1.0" )))
      return _duplicate( (DynamicAny::DynFixed_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynFixed_ptr
DynamicAny::DynFixed::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynEnum::~DynEnum()
{
}

void *
DynamicAny::DynEnum::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynEnum:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynEnum_ptr
DynamicAny::DynEnum::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynEnum:1.0" )))
      return _duplicate( (DynamicAny::DynEnum_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynEnum_ptr
DynamicAny::DynEnum::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}
# 423 "dynany.cc"
class _Marshaller_DynamicAny_NameValuePair : public CORBA::StaticTypeInfo {
    typedef DynamicAny::NameValuePair _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller_DynamicAny_NameValuePair::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_DynamicAny_NameValuePair::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_DynamicAny_NameValuePair::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_DynamicAny_NameValuePair::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  return
    dc.struct_begin() &&
    CORBA::_stc_string->demarshal( dc, &((_MICO_T*)v)->id._for_demarshal() ) &&
    CORBA::_stc_any->demarshal( dc, &((_MICO_T*)v)->value ) &&
    dc.struct_end();
}

void _Marshaller_DynamicAny_NameValuePair::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.struct_begin();
  CORBA::_stc_string->marshal( ec, &((_MICO_T*)v)->id.inout() );
  CORBA::_stc_any->marshal( ec, &((_MICO_T*)v)->value );
  ec.struct_end();
}

CORBA::StaticTypeInfo *_marshaller_DynamicAny_NameValuePair;
# 499 "dynany.cc"
DynamicAny::DynStruct::~DynStruct()
{
}

void *
DynamicAny::DynStruct::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynStruct:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynStruct_ptr
DynamicAny::DynStruct::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynStruct:1.0" )))
      return _duplicate( (DynamicAny::DynStruct_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynStruct_ptr
DynamicAny::DynStruct::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynUnion::~DynUnion()
{
}

void *
DynamicAny::DynUnion::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynUnion:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynUnion_ptr
DynamicAny::DynUnion::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynUnion:1.0" )))
      return _duplicate( (DynamicAny::DynUnion_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynUnion_ptr
DynamicAny::DynUnion::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}
# 585 "dynany.cc"
DynamicAny::DynSequence::~DynSequence()
{
}

void *
DynamicAny::DynSequence::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynSequence:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynSequence_ptr
DynamicAny::DynSequence::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynSequence:1.0" )))
      return _duplicate( (DynamicAny::DynSequence_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynSequence_ptr
DynamicAny::DynSequence::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynArray::~DynArray()
{
}

void *
DynamicAny::DynArray::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynArray:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynArray_ptr
DynamicAny::DynArray::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynArray:1.0" )))
      return _duplicate( (DynamicAny::DynArray_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynArray_ptr
DynamicAny::DynArray::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynValueCommon::~DynValueCommon()
{
}

void *
DynamicAny::DynValueCommon::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynValueCommon:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynAny _VCHACK__DynamicAny__DynAny;
    _VCHACK__DynamicAny__DynAny *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynAny::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynValueCommon_ptr
DynamicAny::DynValueCommon::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynValueCommon:1.0" )))
      return _duplicate( (DynamicAny::DynValueCommon_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynValueCommon_ptr
DynamicAny::DynValueCommon::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynValue::~DynValue()
{
}

void *
DynamicAny::DynValue::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynValue:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynValueCommon _VCHACK__DynamicAny__DynValueCommon;
    _VCHACK__DynamicAny__DynValueCommon *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynValueCommon::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynValue_ptr
DynamicAny::DynValue::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynValue:1.0" )))
      return _duplicate( (DynamicAny::DynValue_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynValue_ptr
DynamicAny::DynValue::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}







DynamicAny::DynValueBox::~DynValueBox()
{
}

void *
DynamicAny::DynValueBox::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynValueBox:1.0" ) == 0 )
    return (void *)this;
  {
    void *_p;
    typedef DynamicAny::DynValueCommon _VCHACK__DynamicAny__DynValueCommon;
    _VCHACK__DynamicAny__DynValueCommon *_tp = this;
    if ((_p = _tp->_VCHACK__DynamicAny__DynValueCommon::_narrow_helper( _repoid )))
      return _p;
  }
  return __null;
}

DynamicAny::DynValueBox_ptr
DynamicAny::DynValueBox::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynValueBox:1.0" )))
      return _duplicate( (DynamicAny::DynValueBox_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynValueBox_ptr
DynamicAny::DynValueBox::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}
# 811 "dynany.cc"
class _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode : public CORBA::StaticTypeInfo {
    typedef ::DynamicAny::DynAnyFactory::InconsistentTypeCode _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  string repoid;
  return
    dc.except_begin( repoid ) &&
    dc.except_end();
}

void _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ec.except_begin( "IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0" );
  ec.except_end();
}

CORBA::StaticTypeInfo *_marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode;

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_throwit() const
{


  throw *this;






}

const char *DynamicAny::DynAnyFactory::InconsistentTypeCode::_repoid() const
{
  return "IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0";
}

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_encode( CORBA::DataEncoder &_en ) const
{
  _marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode->marshal( _en, (void*) this );
}

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_encode_any( CORBA::Any &_a ) const
{

  ((void) ((0) ? 0 : (__assert_fail ("0", "dynany.cc", 879, __PRETTY_FUNCTION__), 0)));
}

CORBA::Exception *DynamicAny::DynAnyFactory::InconsistentTypeCode::_clone() const
{
  return new InconsistentTypeCode( *this );
}

DynamicAny::DynAnyFactory::InconsistentTypeCode *DynamicAny::DynAnyFactory::InconsistentTypeCode::_downcast( CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0" ) )
    return (InconsistentTypeCode *) _ex;
  return __null;
}

const DynamicAny::DynAnyFactory::InconsistentTypeCode *DynamicAny::DynAnyFactory::InconsistentTypeCode::_downcast( const CORBA::Exception *_ex )
{
  if( _ex && !strcmp( _ex->_repoid(), "IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0" ) )
    return (InconsistentTypeCode *) _ex;
  return __null;
}






DynamicAny::DynAnyFactory::~DynAnyFactory()
{
}

void *
DynamicAny::DynAnyFactory::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:omg.org/DynamicAny/DynAnyFactory:1.0" ) == 0 )
    return (void *)this;
  return __null;
}

DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory::_narrow( CORBA::Object_ptr _obj )
{
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:omg.org/DynamicAny/DynAnyFactory:1.0" )))
      return _duplicate( (DynamicAny::DynAnyFactory_ptr) _p );
  }
  return _nil();
}

DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}


class _Marshaller__seq_DynamicAny_NameValuePair : public CORBA::StaticTypeInfo {
    typedef SequenceTmpl<DynamicAny::NameValuePair,0> _MICO_T;
  public:
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
    void marshal (CORBA::DataEncoder &, StaticValueType) const;
};


CORBA::StaticValueType _Marshaller__seq_DynamicAny_NameValuePair::create() const
{
  return (StaticValueType) new _MICO_T;
}

void _Marshaller__seq_DynamicAny_NameValuePair::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = *(_MICO_T*) s;
}

void _Marshaller__seq_DynamicAny_NameValuePair::free( StaticValueType v ) const
{
  delete (_MICO_T*) v;
}

CORBA::Boolean _Marshaller__seq_DynamicAny_NameValuePair::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
{
  CORBA::ULong len;
  if( !dc.seq_begin( len ) )
    return 0;
  ((_MICO_T *) v)->length( len );
  for( CORBA::ULong i = 0; i < len; i++ ) {
    if( !_marshaller_DynamicAny_NameValuePair->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
      return 0;
  }
  return dc.seq_end();
}

void _Marshaller__seq_DynamicAny_NameValuePair::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
{
  CORBA::ULong len = ((_MICO_T *) v)->length();
  ec.seq_begin( len );
  for( CORBA::ULong i = 0; i < len; i++ )
    _marshaller_DynamicAny_NameValuePair->marshal( ec, &(*(_MICO_T*)v)[i] );
  ec.seq_end();
}

CORBA::StaticTypeInfo *_marshaller__seq_DynamicAny_NameValuePair;

struct __tc_init_DYNANY {
  __tc_init_DYNANY()
  {
    _marshaller_DynamicAny_DynAny_InvalidValue = new _Marshaller_DynamicAny_DynAny_InvalidValue;
    _marshaller_DynamicAny_DynAny_TypeMismatch = new _Marshaller_DynamicAny_DynAny_TypeMismatch;
    _marshaller_DynamicAny_NameValuePair = new _Marshaller_DynamicAny_NameValuePair;
    _marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode = new _Marshaller_DynamicAny_DynAnyFactory_InconsistentTypeCode;
    _marshaller__seq_DynamicAny_NameValuePair = new _Marshaller__seq_DynamicAny_NameValuePair;
  }
};

static __tc_init_DYNANY __init_DYNANY;
# 44 "orb_all.cc" 2
# 1 "ssliop.cc" 1







# 1 "../include/mico/ssliop.h" 1
# 12 "../include/mico/ssliop.h"
# 1 "../include/CORBA.h" 1
# 13 "../include/mico/ssliop.h" 2
# 1 "../include/mico/throw.h" 1
# 14 "../include/mico/ssliop.h" 2






# 1 "../include/mico/current.h" 1
# 21 "../include/mico/ssliop.h" 2




namespace Security {





typedef CORBA::UShort AssociationOptions;
typedef AssociationOptions& AssociationOptions_out;
extern const CORBA::UShort NoProtection;
extern const CORBA::UShort Integrity;
extern const CORBA::UShort Confidentiality;
extern const CORBA::UShort DetectReplay;
extern const CORBA::UShort DetectMisordering;
extern const CORBA::UShort EstablishTrustInTarget;
extern const CORBA::UShort EstablishTrustInClient;




}





namespace SSLIOP {





struct SSL;
typedef TFixVar<SSL> SSL_var;
typedef SSL& SSL_out;

struct SSL {

  typedef SSL_var _var_type;
# 71 "../include/mico/ssliop.h"
  Security::AssociationOptions target_supports;
  Security::AssociationOptions target_requires;
  CORBA::UShort port;
};





}
# 95 "../include/mico/ssliop.h"
# 1 "../include/mico/template_impl.h" 1
# 96 "../include/mico/ssliop.h" 2
# 9 "ssliop.cc" 2






namespace Security { const CORBA::UShort NoProtection = 1; }




namespace Security { const CORBA::UShort Integrity = 2; }




namespace Security { const CORBA::UShort Confidentiality = 4; }




namespace Security { const CORBA::UShort DetectReplay = 8; }




namespace Security { const CORBA::UShort DetectMisordering = 16; }




namespace Security { const CORBA::UShort EstablishTrustInTarget = 32; }




namespace Security { const CORBA::UShort EstablishTrustInClient = 64; }
# 75 "ssliop.cc"
struct __tc_init_SSLIOP {
  __tc_init_SSLIOP()
  {
  }
};

static __tc_init_SSLIOP __init_SSLIOP;
# 45 "orb_all.cc" 2


>Fix:
	
>Release-Note:
>Audit-Trail:
>Unformatted:

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]