# 1 "sc_wif_trace.cpp"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "sc_wif_trace.cpp"
# 62 "sc_wif_trace.cpp"
# 1 "/usr/include/assert.h" 1 3 4
# 36 "/usr/include/assert.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 314 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 315 "/usr/include/features.h" 2 3 4
# 337 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 338 "/usr/include/features.h" 2 3 4
# 37 "/usr/include/assert.h" 2 3 4
# 65 "/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__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 63 "sc_wif_trace.cpp" 2
# 1 "/usr/include/time.h" 1 3 4
# 30 "/usr/include/time.h" 3 4
extern "C" {







# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 213 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 3 4
typedef unsigned int size_t;
# 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
# 56 "/usr/include/time.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


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


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;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 57 "/usr/include/time.h" 2 3 4



typedef __clock_t clock_t;



# 74 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 118 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };








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;




};








struct itimerspec
  {
    struct timespec it_interval;
    struct timespec it_value;
  };


struct sigevent;





typedef __pid_t pid_t;








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 *__restrict __s,
         __const char *__restrict __fmt, struct tm *__tp)
     throw ();





# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;
# 214 "/usr/include/time.h" 2 3 4

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

extern char *strptime_l (__const char *__restrict __s,
    __const char *__restrict __fmt, struct tm *__tp,
    __locale_t __loc) 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 *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 ();
# 309 "/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 () __attribute__ ((__const__));
# 324 "/usr/include/time.h" 3 4
extern int nanosleep (__const struct timespec *__requested_time,
        struct timespec *__remaining);



extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();


extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
     throw ();






extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       __const struct timespec *__req,
       struct timespec *__rem);


extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) throw ();


extern int timer_delete (timer_t __timerid) throw ();


extern int timer_settime (timer_t __timerid, int __flags,
     __const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) throw ();


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     throw ();


extern int timer_getoverrun (timer_t __timerid) throw ();
# 386 "/usr/include/time.h" 3 4
extern int getdate_err;
# 395 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 409 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 64 "sc_wif_trace.cpp" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 65 "/usr/include/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 66 "/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;
  };
# 44 "/usr/include/stdlib.h" 2 3 4
# 96 "/usr/include/stdlib.h" 3 4


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;


# 140 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw ();




extern double atof (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern int atoi (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern long int atol (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





__extension__ extern long long int atoll (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





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





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

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





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

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




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

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

# 239 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (__const char *__restrict __nptr,
   char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (__const char *__restrict __nptr,
         char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (__const char *__restrict __nptr,
         char **__restrict __endptr,
         __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3)));






extern double __strtod_internal (__const char *__restrict __nptr,
     char **__restrict __endptr, int __group)
     throw () __attribute__ ((__nonnull__ (1)));
extern float __strtof_internal (__const char *__restrict __nptr,
    char **__restrict __endptr, int __group)
     throw () __attribute__ ((__nonnull__ (1)));
extern long double __strtold_internal (__const char *__restrict __nptr,
           char **__restrict __endptr,
           int __group) throw () __attribute__ ((__nonnull__ (1)));

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



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




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



__extension__
extern unsigned long long int __strtoull_internal (__const char *
         __restrict __nptr,
         char **__restrict __endptr,
         int __base, int __group)
     throw () __attribute__ ((__nonnull__ (1)));








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);
}

# 424 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw ();


extern long int a64l (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




# 1 "/usr/include/sys/types.h" 1 3 4
# 29 "/usr/include/sys/types.h" 3 4
extern "C" {





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;
# 105 "/usr/include/sys/types.h" 3 4
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;
# 137 "/usr/include/sys/types.h" 3 4
typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 191 "/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__)));
# 216 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 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



typedef __sigset_t sigset_t;







# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 67 "/usr/include/sys/select.h" 3 4
typedef struct
  {



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





  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4
extern "C" {
# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 121 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);


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


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
       unsigned int __minor)
     throw ();


__extension__ extern __inline unsigned int
gnu_dev_major (unsigned long long int __dev) throw ()
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
gnu_dev_minor (unsigned long long int __dev) throw ()
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
   | (((unsigned long long int) (__minor & ~0xff)) << 12)
   | (((unsigned long long int) (__major & ~0xfff)) << 32));
}
# 220 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;






typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 258 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_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
# 83 "/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 __pthread_attr_s
{
  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;





__extension__ typedef long long __pthread_cond_align_t;




typedef struct
{
  struct _pthread_fastlock __c_lock;
  _pthread_descr __c_waiting;
  char __padding[48 - sizeof (struct _pthread_fastlock)
   - sizeof (_pthread_descr) - sizeof (__pthread_cond_align_t)];
  __pthread_cond_align_t __align;
} 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 volatile int pthread_spinlock_t;


typedef struct {
  struct _pthread_fastlock __ba_lock;
  int __ba_required;
  int __ba_present;
  _pthread_descr __ba_waiting;
} pthread_barrier_t;


typedef struct {
  int __pshared;
} pthread_barrierattr_t;





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


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






extern long int random (void) throw ();


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





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));







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 () __attribute__ ((__nonnull__ (1, 2)));

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

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));






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 () __attribute__ ((__nonnull__ (1)));


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


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


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





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


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


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


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


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

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

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (1, 2)));









extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__));

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







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

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




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



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





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





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




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




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));




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



extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));





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






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






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






extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));




extern char *__secure_getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));





extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));





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


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






extern int clearenv (void) throw ();
# 691 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 702 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1)));
# 711 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1)));
# 721 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));








extern int system (__const char *__command);







extern char *canonicalize_file_name (__const char *__name)
     throw () __attribute__ ((__nonnull__ (1)));
# 749 "/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)
     __attribute__ ((__nonnull__ (1, 2, 5)));



extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));



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__));

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




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




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




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4)));
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4)));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3)));




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));







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 ();








extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1)));
# 902 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *__const *__restrict __tokens,
        char **__restrict __valuep)
     throw () __attribute__ ((__nonnull__ (1, 2, 3)));





extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag);







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 () __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     throw () __attribute__ ((__nonnull__ (1)));





}
# 65 "sc_wif_trace.cpp" 2

# 1 "../../../src/systemc/kernel/sc_simcontext.h" 1
# 58 "../../../src/systemc/kernel/sc_simcontext.h"
# 1 "../../../src/systemc/kernel/sc_cmnhdr.h" 1
# 106 "../../../src/systemc/kernel/sc_cmnhdr.h"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 107 "../../../src/systemc/kernel/sc_cmnhdr.h" 2
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 44 "/usr/include/stdio.h" 3 4


typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 354 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 24 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3 4

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/gconv.h" 1 3 4
# 28 "/usr/include/gconv.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 29 "/usr/include/gconv.h" 2 3 4


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
       __const unsigned char **, __const unsigned char *,
       unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
      struct __gconv_step_data *, void *,
      __const unsigned char *,
      __const unsigned char **,
      __const unsigned char *, unsigned char **,
      size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
       __const unsigned char *,
       unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
     size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

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__)));
# 33 "/usr/include/libio.h" 2 3 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 166 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 176 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





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



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


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 267 "/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 _flags2;

  __off_t _old_offset;



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



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





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};





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_;
# 354 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
     size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_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;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
        void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
extern wint_t __wunderflow (_IO_FILE *) throw ();
extern wint_t __wuflow (_IO_FILE *) throw ();
extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
# 444 "/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 ();
# 474 "/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 ();
# 532 "/usr/include/libio.h" 3 4
}
# 73 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 86 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;









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

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









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



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





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








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 223 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 233 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);









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




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


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




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 *fmemopen (void *__s, size_t __len, __const char *__modes) 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, ...);




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

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);




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

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 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)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








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




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

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)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __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);
extern int getc (FILE *__stream);





extern int getchar (void);

# 456 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 467 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











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





extern int putchar (int __c);

# 500 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







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






extern int getw (FILE *__stream);


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








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






extern char *gets (char *__s);

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







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








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





extern int puts (__const char *__s);






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






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




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

# 622 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
# 633 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);








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




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

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




extern __off_t ftello (FILE *__stream);
# 688 "/usr/include/stdio.h" 3 4






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




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 711 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




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);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 750 "/usr/include/stdio.h" 2 3 4




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




extern int fileno_unlocked (FILE *__stream) throw ();
# 769 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





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





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       __const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







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



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


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


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




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


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




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




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





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


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





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  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);
}
# 831 "/usr/include/stdio.h" 2 3 4





}
# 108 "../../../src/systemc/kernel/sc_cmnhdr.h" 2
# 59 "../../../src/systemc/kernel/sc_simcontext.h" 2
# 1 "../../../src/systemc/kernel/sc_process.h" 1
# 41 "../../../src/systemc/kernel/sc_process.h"
# 1 "../../../src/systemc/utils/sc_iostream.h" 1
# 42 "../../../src/systemc/utils/sc_iostream.h"
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 1 3
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 3
       
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++config.h" 1 3
# 35 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++config.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/os_defines.h" 1 3
# 36 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++config.h" 2 3
# 57 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++config.h" 3
namespace __gnu_debug_def { }

namespace __gnu_debug
{
  using namespace __gnu_debug_def;
}
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 1 3
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 3
       
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 1 3
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 3
       
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstddef" 1 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstddef" 3
       
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstddef" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 151 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstddef" 2 3

namespace std
{
  using ::ptrdiff_t;
  using ::size_t;
}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 2 3

# 1 "/usr/include/string.h" 1 3 4
# 28 "/usr/include/string.h" 3 4
extern "C" {




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/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 () __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





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


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern void *rawmemchr (__const void *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

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

# 121 "/usr/include/string.h" 3 4
extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));




extern char *strdup (__const char *__s)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 165 "/usr/include/string.h" 3 4


extern char *strchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strchrnul (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



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




extern char *__strtok_r (char *__restrict __s,
    __const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));




extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern void *memmem (__const void *__haystack, size_t __haystacklen,
       __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





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

# 281 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));





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



extern void bcopy (__const void *__src, void *__dest, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


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


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *index (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern char *rindex (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));



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 () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
    __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
     size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
       __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


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


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


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






extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
# 426 "/usr/include/string.h" 3 4
}
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 2 3
# 77 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstring" 3
namespace std
{
  using ::memcpy;
  using ::memmove;
  using ::strcpy;
  using ::strncpy;
  using ::strcat;
  using ::strncat;
  using ::memcmp;
  using ::strcmp;
  using ::strcoll;
  using ::strncmp;
  using ::strxfrm;
  using ::strcspn;
  using ::strspn;
  using ::strtok;
  using ::memset;
  using ::strerror;
  using ::strlen;

  using ::memchr;

  inline void*
  memchr(void* __p, int __c, size_t __n)
  { return memchr(const_cast<const void*>(__p), __c, __n); }

  using ::strchr;

  inline char*
  strchr(char* __s1, int __n)
  { return __builtin_strchr(const_cast<const char*>(__s1), __n); }

  using ::strpbrk;

  inline char*
  strpbrk(char* __s1, const char* __s2)
  { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }

  using ::strrchr;

  inline char*
  strrchr(char* __s1, int __n)
  { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }

  using ::strstr;

  inline char*
  strstr(char* __s1, const char* __s2)
  { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
}
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 3
# 97 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 3
namespace std
{
  using ::FILE;
  using ::fpos_t;

  using ::clearerr;
  using ::fclose;
  using ::feof;
  using ::ferror;
  using ::fflush;
  using ::fgetc;
  using ::fgetpos;
  using ::fgets;
  using ::fopen;
  using ::fprintf;
  using ::fputc;
  using ::fputs;
  using ::fread;
  using ::freopen;
  using ::fscanf;
  using ::fseek;
  using ::fsetpos;
  using ::ftell;
  using ::fwrite;
  using ::getc;
  using ::getchar;
  using ::gets;
  using ::perror;
  using ::printf;
  using ::putc;
  using ::putchar;
  using ::puts;
  using ::remove;
  using ::rename;
  using ::rewind;
  using ::scanf;
  using ::setbuf;
  using ::setvbuf;
  using ::sprintf;
  using ::sscanf;
  using ::tmpfile;
  using ::tmpnam;
  using ::ungetc;
  using ::vfprintf;
  using ::vprintf;
  using ::vsprintf;
}
# 153 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 3
namespace __gnu_cxx
{
# 167 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdio" 3
  using ::snprintf;
  using ::vfscanf;
  using ::vscanf;
  using ::vsnprintf;
  using ::vsscanf;

}

namespace std
{
  using __gnu_cxx::snprintf;
  using __gnu_cxx::vfscanf;
  using __gnu_cxx::vscanf;
  using __gnu_cxx::vsnprintf;
  using __gnu_cxx::vsscanf;
}
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/clocale" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/clocale" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/clocale" 3

# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 27 "/usr/include/bits/locale.h" 3 4
enum
{
  __LC_CTYPE = 0,
  __LC_NUMERIC = 1,
  __LC_TIME = 2,
  __LC_COLLATE = 3,
  __LC_MONETARY = 4,
  __LC_MESSAGES = 5,
  __LC_ALL = 6,
  __LC_PAPER = 7,
  __LC_NAME = 8,
  __LC_ADDRESS = 9,
  __LC_TELEPHONE = 10,
  __LC_MEASUREMENT = 11,
  __LC_IDENTIFICATION = 12
};
# 31 "/usr/include/locale.h" 2 3 4

extern "C" {
# 52 "/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;


  char int_p_cs_precedes;

  char int_p_sep_by_space;

  char int_n_cs_precedes;

  char int_n_sep_by_space;






  char int_p_sign_posn;
  char int_n_sign_posn;
# 119 "/usr/include/locale.h" 3 4
};





extern char *setlocale (int __category, __const char *__locale) throw ();


extern struct lconv *localeconv (void) throw ();


# 148 "/usr/include/locale.h" 3 4
typedef __locale_t locale_t;





extern __locale_t newlocale (int __category_mask, __const char *__locale,
        __locale_t __base) throw ();
# 189 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) throw ();



extern void freelocale (__locale_t __dataset) throw ();






extern __locale_t uselocale (__locale_t __dataset) throw ();







}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/clocale" 2 3





namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3
# 1 "/usr/include/langinfo.h" 1 3 4
# 24 "/usr/include/langinfo.h" 3 4
# 1 "/usr/include/nl_types.h" 1 3 4
# 31 "/usr/include/nl_types.h" 3 4
extern "C" {


typedef void *nl_catd;


typedef int nl_item;





extern nl_catd catopen (__const char *__cat_name, int __flag) __attribute__ ((__nonnull__ (1)));



extern char *catgets (nl_catd __catalog, int __set, int __number,
        __const char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern int catclose (nl_catd __catalog) throw () __attribute__ ((__nonnull__ (1)));

}
# 25 "/usr/include/langinfo.h" 2 3 4

# 1 "/usr/include/bits/locale.h" 1 3 4
# 27 "/usr/include/langinfo.h" 2 3 4


extern "C" {
# 43 "/usr/include/langinfo.h" 3 4
enum
{



  ABDAY_1 = (((__LC_TIME) << 16) | (0)),

  ABDAY_2,

  ABDAY_3,

  ABDAY_4,

  ABDAY_5,

  ABDAY_6,

  ABDAY_7,



  DAY_1,

  DAY_2,

  DAY_3,

  DAY_4,

  DAY_5,

  DAY_6,

  DAY_7,



  ABMON_1,

  ABMON_2,

  ABMON_3,

  ABMON_4,

  ABMON_5,

  ABMON_6,

  ABMON_7,

  ABMON_8,

  ABMON_9,

  ABMON_10,

  ABMON_11,

  ABMON_12,



  MON_1,

  MON_2,

  MON_3,

  MON_4,

  MON_5,

  MON_6,

  MON_7,

  MON_8,

  MON_9,

  MON_10,

  MON_11,

  MON_12,


  AM_STR,

  PM_STR,


  D_T_FMT,

  D_FMT,

  T_FMT,

  T_FMT_AMPM,


  ERA,

  __ERA_YEAR,



  ERA_D_FMT,

  ALT_DIGITS,

  ERA_D_T_FMT,

  ERA_T_FMT,


  _NL_TIME_ERA_NUM_ENTRIES,
  _NL_TIME_ERA_ENTRIES,

  _NL_WABDAY_1,
  _NL_WABDAY_2,
  _NL_WABDAY_3,
  _NL_WABDAY_4,
  _NL_WABDAY_5,
  _NL_WABDAY_6,
  _NL_WABDAY_7,


  _NL_WDAY_1,
  _NL_WDAY_2,
  _NL_WDAY_3,
  _NL_WDAY_4,
  _NL_WDAY_5,
  _NL_WDAY_6,
  _NL_WDAY_7,


  _NL_WABMON_1,
  _NL_WABMON_2,
  _NL_WABMON_3,
  _NL_WABMON_4,
  _NL_WABMON_5,
  _NL_WABMON_6,
  _NL_WABMON_7,
  _NL_WABMON_8,
  _NL_WABMON_9,
  _NL_WABMON_10,
  _NL_WABMON_11,
  _NL_WABMON_12,


  _NL_WMON_1,
  _NL_WMON_2,
  _NL_WMON_3,
  _NL_WMON_4,
  _NL_WMON_5,
  _NL_WMON_6,
  _NL_WMON_7,
  _NL_WMON_8,
  _NL_WMON_9,
  _NL_WMON_10,
  _NL_WMON_11,
  _NL_WMON_12,

  _NL_WAM_STR,
  _NL_WPM_STR,

  _NL_WD_T_FMT,
  _NL_WD_FMT,
  _NL_WT_FMT,
  _NL_WT_FMT_AMPM,

  _NL_WERA_YEAR,
  _NL_WERA_D_FMT,
  _NL_WALT_DIGITS,
  _NL_WERA_D_T_FMT,
  _NL_WERA_T_FMT,

  _NL_TIME_WEEK_NDAYS,
  _NL_TIME_WEEK_1STDAY,
  _NL_TIME_WEEK_1STWEEK,
  _NL_TIME_FIRST_WEEKDAY,
  _NL_TIME_FIRST_WORKDAY,
  _NL_TIME_CAL_DIRECTION,
  _NL_TIME_TIMEZONE,

  _DATE_FMT,

  _NL_W_DATE_FMT,

  _NL_TIME_CODESET,

  _NL_NUM_LC_TIME,




  _NL_COLLATE_NRULES = (((__LC_COLLATE) << 16) | (0)),
  _NL_COLLATE_RULESETS,
  _NL_COLLATE_TABLEMB,
  _NL_COLLATE_WEIGHTMB,
  _NL_COLLATE_EXTRAMB,
  _NL_COLLATE_INDIRECTMB,
  _NL_COLLATE_GAP1,
  _NL_COLLATE_GAP2,
  _NL_COLLATE_GAP3,
  _NL_COLLATE_TABLEWC,
  _NL_COLLATE_WEIGHTWC,
  _NL_COLLATE_EXTRAWC,
  _NL_COLLATE_INDIRECTWC,
  _NL_COLLATE_SYMB_HASH_SIZEMB,
  _NL_COLLATE_SYMB_TABLEMB,
  _NL_COLLATE_SYMB_EXTRAMB,
  _NL_COLLATE_COLLSEQMB,
  _NL_COLLATE_COLLSEQWC,
  _NL_COLLATE_CODESET,
  _NL_NUM_LC_COLLATE,




  _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
  _NL_CTYPE_TOUPPER,
  _NL_CTYPE_GAP1,
  _NL_CTYPE_TOLOWER,
  _NL_CTYPE_GAP2,
  _NL_CTYPE_CLASS32,
  _NL_CTYPE_GAP3,
  _NL_CTYPE_GAP4,
  _NL_CTYPE_GAP5,
  _NL_CTYPE_GAP6,
  _NL_CTYPE_CLASS_NAMES,
  _NL_CTYPE_MAP_NAMES,
  _NL_CTYPE_WIDTH,
  _NL_CTYPE_MB_CUR_MAX,
  _NL_CTYPE_CODESET_NAME,
  CODESET = _NL_CTYPE_CODESET_NAME,

  _NL_CTYPE_TOUPPER32,
  _NL_CTYPE_TOLOWER32,
  _NL_CTYPE_CLASS_OFFSET,
  _NL_CTYPE_MAP_OFFSET,
  _NL_CTYPE_INDIGITS_MB_LEN,
  _NL_CTYPE_INDIGITS0_MB,
  _NL_CTYPE_INDIGITS1_MB,
  _NL_CTYPE_INDIGITS2_MB,
  _NL_CTYPE_INDIGITS3_MB,
  _NL_CTYPE_INDIGITS4_MB,
  _NL_CTYPE_INDIGITS5_MB,
  _NL_CTYPE_INDIGITS6_MB,
  _NL_CTYPE_INDIGITS7_MB,
  _NL_CTYPE_INDIGITS8_MB,
  _NL_CTYPE_INDIGITS9_MB,
  _NL_CTYPE_INDIGITS_WC_LEN,
  _NL_CTYPE_INDIGITS0_WC,
  _NL_CTYPE_INDIGITS1_WC,
  _NL_CTYPE_INDIGITS2_WC,
  _NL_CTYPE_INDIGITS3_WC,
  _NL_CTYPE_INDIGITS4_WC,
  _NL_CTYPE_INDIGITS5_WC,
  _NL_CTYPE_INDIGITS6_WC,
  _NL_CTYPE_INDIGITS7_WC,
  _NL_CTYPE_INDIGITS8_WC,
  _NL_CTYPE_INDIGITS9_WC,
  _NL_CTYPE_OUTDIGIT0_MB,
  _NL_CTYPE_OUTDIGIT1_MB,
  _NL_CTYPE_OUTDIGIT2_MB,
  _NL_CTYPE_OUTDIGIT3_MB,
  _NL_CTYPE_OUTDIGIT4_MB,
  _NL_CTYPE_OUTDIGIT5_MB,
  _NL_CTYPE_OUTDIGIT6_MB,
  _NL_CTYPE_OUTDIGIT7_MB,
  _NL_CTYPE_OUTDIGIT8_MB,
  _NL_CTYPE_OUTDIGIT9_MB,
  _NL_CTYPE_OUTDIGIT0_WC,
  _NL_CTYPE_OUTDIGIT1_WC,
  _NL_CTYPE_OUTDIGIT2_WC,
  _NL_CTYPE_OUTDIGIT3_WC,
  _NL_CTYPE_OUTDIGIT4_WC,
  _NL_CTYPE_OUTDIGIT5_WC,
  _NL_CTYPE_OUTDIGIT6_WC,
  _NL_CTYPE_OUTDIGIT7_WC,
  _NL_CTYPE_OUTDIGIT8_WC,
  _NL_CTYPE_OUTDIGIT9_WC,
  _NL_CTYPE_TRANSLIT_TAB_SIZE,
  _NL_CTYPE_TRANSLIT_FROM_IDX,
  _NL_CTYPE_TRANSLIT_FROM_TBL,
  _NL_CTYPE_TRANSLIT_TO_IDX,
  _NL_CTYPE_TRANSLIT_TO_TBL,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
  _NL_CTYPE_TRANSLIT_IGNORE_LEN,
  _NL_CTYPE_TRANSLIT_IGNORE,
  _NL_CTYPE_MAP_TO_NONASCII,
  _NL_CTYPE_EXTRA_MAP_1,
  _NL_CTYPE_EXTRA_MAP_2,
  _NL_CTYPE_EXTRA_MAP_3,
  _NL_CTYPE_EXTRA_MAP_4,
  _NL_CTYPE_EXTRA_MAP_5,
  _NL_CTYPE_EXTRA_MAP_6,
  _NL_CTYPE_EXTRA_MAP_7,
  _NL_CTYPE_EXTRA_MAP_8,
  _NL_CTYPE_EXTRA_MAP_9,
  _NL_CTYPE_EXTRA_MAP_10,
  _NL_CTYPE_EXTRA_MAP_11,
  _NL_CTYPE_EXTRA_MAP_12,
  _NL_CTYPE_EXTRA_MAP_13,
  _NL_CTYPE_EXTRA_MAP_14,
  _NL_NUM_LC_CTYPE,




  __INT_CURR_SYMBOL = (((__LC_MONETARY) << 16) | (0)),



  __CURRENCY_SYMBOL,



  __MON_DECIMAL_POINT,



  __MON_THOUSANDS_SEP,



  __MON_GROUPING,



  __POSITIVE_SIGN,



  __NEGATIVE_SIGN,



  __INT_FRAC_DIGITS,



  __FRAC_DIGITS,



  __P_CS_PRECEDES,



  __P_SEP_BY_SPACE,



  __N_CS_PRECEDES,



  __N_SEP_BY_SPACE,



  __P_SIGN_POSN,



  __N_SIGN_POSN,



  _NL_MONETARY_CRNCYSTR,

  __INT_P_CS_PRECEDES,



  __INT_P_SEP_BY_SPACE,



  __INT_N_CS_PRECEDES,



  __INT_N_SEP_BY_SPACE,



  __INT_P_SIGN_POSN,



  __INT_N_SIGN_POSN,



  _NL_MONETARY_DUO_INT_CURR_SYMBOL,
  _NL_MONETARY_DUO_CURRENCY_SYMBOL,
  _NL_MONETARY_DUO_INT_FRAC_DIGITS,
  _NL_MONETARY_DUO_FRAC_DIGITS,
  _NL_MONETARY_DUO_P_CS_PRECEDES,
  _NL_MONETARY_DUO_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_N_CS_PRECEDES,
  _NL_MONETARY_DUO_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_P_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_N_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_P_SIGN_POSN,
  _NL_MONETARY_DUO_N_SIGN_POSN,
  _NL_MONETARY_DUO_INT_P_SIGN_POSN,
  _NL_MONETARY_DUO_INT_N_SIGN_POSN,
  _NL_MONETARY_UNO_VALID_FROM,
  _NL_MONETARY_UNO_VALID_TO,
  _NL_MONETARY_DUO_VALID_FROM,
  _NL_MONETARY_DUO_VALID_TO,
  _NL_MONETARY_CONVERSION_RATE,
  _NL_MONETARY_DECIMAL_POINT_WC,
  _NL_MONETARY_THOUSANDS_SEP_WC,
  _NL_MONETARY_CODESET,
  _NL_NUM_LC_MONETARY,



  __DECIMAL_POINT = (((__LC_NUMERIC) << 16) | (0)),



  RADIXCHAR = __DECIMAL_POINT,

  __THOUSANDS_SEP,



  THOUSEP = __THOUSANDS_SEP,

  __GROUPING,



  _NL_NUMERIC_DECIMAL_POINT_WC,
  _NL_NUMERIC_THOUSANDS_SEP_WC,
  _NL_NUMERIC_CODESET,
  _NL_NUM_LC_NUMERIC,

  __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),

  __NOEXPR,

  __YESSTR,



  __NOSTR,



  _NL_MESSAGES_CODESET,
  _NL_NUM_LC_MESSAGES,

  _NL_PAPER_HEIGHT = (((__LC_PAPER) << 16) | (0)),
  _NL_PAPER_WIDTH,
  _NL_PAPER_CODESET,
  _NL_NUM_LC_PAPER,

  _NL_NAME_NAME_FMT = (((__LC_NAME) << 16) | (0)),
  _NL_NAME_NAME_GEN,
  _NL_NAME_NAME_MR,
  _NL_NAME_NAME_MRS,
  _NL_NAME_NAME_MISS,
  _NL_NAME_NAME_MS,
  _NL_NAME_CODESET,
  _NL_NUM_LC_NAME,

  _NL_ADDRESS_POSTAL_FMT = (((__LC_ADDRESS) << 16) | (0)),
  _NL_ADDRESS_COUNTRY_NAME,
  _NL_ADDRESS_COUNTRY_POST,
  _NL_ADDRESS_COUNTRY_AB2,
  _NL_ADDRESS_COUNTRY_AB3,
  _NL_ADDRESS_COUNTRY_CAR,
  _NL_ADDRESS_COUNTRY_NUM,
  _NL_ADDRESS_COUNTRY_ISBN,
  _NL_ADDRESS_LANG_NAME,
  _NL_ADDRESS_LANG_AB,
  _NL_ADDRESS_LANG_TERM,
  _NL_ADDRESS_LANG_LIB,
  _NL_ADDRESS_CODESET,
  _NL_NUM_LC_ADDRESS,

  _NL_TELEPHONE_TEL_INT_FMT = (((__LC_TELEPHONE) << 16) | (0)),
  _NL_TELEPHONE_TEL_DOM_FMT,
  _NL_TELEPHONE_INT_SELECT,
  _NL_TELEPHONE_INT_PREFIX,
  _NL_TELEPHONE_CODESET,
  _NL_NUM_LC_TELEPHONE,

  _NL_MEASUREMENT_MEASUREMENT = (((__LC_MEASUREMENT) << 16) | (0)),
  _NL_MEASUREMENT_CODESET,
  _NL_NUM_LC_MEASUREMENT,

  _NL_IDENTIFICATION_TITLE = (((__LC_IDENTIFICATION) << 16) | (0)),
  _NL_IDENTIFICATION_SOURCE,
  _NL_IDENTIFICATION_ADDRESS,
  _NL_IDENTIFICATION_CONTACT,
  _NL_IDENTIFICATION_EMAIL,
  _NL_IDENTIFICATION_TEL,
  _NL_IDENTIFICATION_FAX,
  _NL_IDENTIFICATION_LANGUAGE,
  _NL_IDENTIFICATION_TERRITORY,
  _NL_IDENTIFICATION_AUDIENCE,
  _NL_IDENTIFICATION_APPLICATION,
  _NL_IDENTIFICATION_ABBREVIATION,
  _NL_IDENTIFICATION_REVISION,
  _NL_IDENTIFICATION_DATE,
  _NL_IDENTIFICATION_CATEGORY,
  _NL_IDENTIFICATION_CODESET,
  _NL_NUM_LC_IDENTIFICATION,


  _NL_NUM
};
# 576 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo (nl_item __item) throw ();
# 587 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo_l (nl_item __item, __locale_t l);


}
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3
# 1 "/usr/include/iconv.h" 1 3 4
# 24 "/usr/include/iconv.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 25 "/usr/include/iconv.h" 2 3 4


extern "C" {


typedef void *iconv_t;







extern iconv_t iconv_open (__const char *__tocode, __const char *__fromcode);




extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
       size_t *__restrict __inbytesleft,
       char **__restrict __outbuf,
       size_t *__restrict __outbytesleft);





extern int iconv_close (iconv_t __cd);

}
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3
# 1 "/usr/include/libintl.h" 1 3 4
# 35 "/usr/include/libintl.h" 3 4
extern "C" {




extern char *gettext (__const char *__msgid) throw ();



extern char *dgettext (__const char *__domainname, __const char *__msgid)
     throw ();
extern char *__dgettext (__const char *__domainname, __const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (__const char *__domainname,
   __const char *__msgid, int __category) throw ();
extern char *__dcgettext (__const char *__domainname,
     __const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));




extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
         unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (__const char *__domainname, __const char *__msgid1,
   __const char *__msgid2, unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
    __const char *__msgid2, unsigned long int __n,
    int __category)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (__const char *__domainname) throw ();



extern char *bindtextdomain (__const char *__domainname,
        __const char *__dirname) throw ();



extern char *bind_textdomain_codeset (__const char *__domainname,
          __const char *__codeset) throw ();
# 120 "/usr/include/libintl.h" 3 4
}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 2 3






namespace __gnu_cxx
{
  extern "C" __typeof(uselocale) __uselocale;
}


namespace std
{
  typedef __locale_t __c_locale;





  template<typename _Tv>
    int
    __convert_from_v(char* __out, const int __size, const char* __fmt,

       _Tv __v, const __c_locale& __cloc, int __prec)
    {
      __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 84 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++locale.h" 3
      const int __ret = std::snprintf(__out, __size, __fmt, __prec, __v);





      __gnu_cxx::__uselocale(__old);




      return __ret;
    }
}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++io.h" 1 3
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++io.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr.h" 1 3
# 104 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 20 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 32 "/usr/include/sched.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 62 "/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 ();


}
# 98 "/usr/include/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 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_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_getscheduler (__pid_t __pid) throw ();


extern int sched_yield (void) throw ();


extern int sched_get_priority_max (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 ();
# 76 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         __const cpu_set_t *__cpuset) throw ();


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) throw ();


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



# 1 "/usr/include/signal.h" 1 3 4
# 31 "/usr/include/signal.h" 3 4
extern "C" {

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 34 "/usr/include/signal.h" 2 3 4
# 400 "/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
# 1 "/usr/include/bits/initspin.h" 1 3 4
# 27 "/usr/include/pthread.h" 2 3 4


extern "C" {
# 59 "/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_TIMED_NP,
  PTHREAD_MUTEX_RECURSIVE_NP,
  PTHREAD_MUTEX_ERRORCHECK_NP,
  PTHREAD_MUTEX_ADAPTIVE_NP

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



  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_ADAPTIVE_NP

};

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
};
# 131 "/usr/include/pthread.h" 3 4
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

};
# 163 "/usr/include/pthread.h" 3 4
extern int pthread_create (pthread_t *__restrict __threadp,
      __const pthread_attr_t *__restrict __attr,
      void *(*__start_routine) (void *),
      void *__restrict __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) __attribute__ ((__noreturn__));




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





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 *__restrict __attr,
           __const struct sched_param *__restrict
           __param) throw ();


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


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


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


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


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


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


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



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


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






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


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





extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) throw ();


extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize) throw ();





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


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





extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) 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 *__restrict __policy,
      struct sched_param *__restrict __param)
     throw ();



extern int pthread_getconcurrency (void) throw ();


extern int pthread_setconcurrency (int __level) throw ();







extern int pthread_yield (void) throw ();






extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex,
          __const pthread_mutexattr_t *__restrict
          __mutex_attr) 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_lock (pthread_mutex_t *__mutex) throw ();



extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        __const struct timespec *__restrict
        __abstime) 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_destroy (pthread_mutexattr_t *__attr) throw ();


extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared) throw ();


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared) throw ();





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


extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind) throw ();







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         __const pthread_condattr_t *__restrict
         __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 *__restrict __cond,
         pthread_mutex_t *__restrict __mutex);





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




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


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


extern int pthread_condattr_getpshared (__const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared) throw ();


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) throw ();







extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    __const pthread_rwlockattr_t *__restrict
    __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_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           __const struct timespec *__restrict
           __abstime) 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_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           __const struct timespec *__restrict
           __abstime) 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 *
       __restrict __attr,
       int *__restrict __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 ();
# 510 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     throw ();


extern int pthread_spin_destroy (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_lock (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_trylock (pthread_spinlock_t *__lock) throw ();


extern int pthread_spin_unlock (pthread_spinlock_t *__lock) throw ();




extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     __const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count) throw ();

extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) throw ();

extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) throw ();

extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) throw ();

extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared) throw ();

extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared) throw ();

extern int pthread_barrier_wait (pthread_barrier_t *__barrier) throw ();
# 557 "/usr/include/pthread.h" 3 4
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 void *pthread_getspecific (pthread_key_t __key) throw ();
# 580 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void));






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



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


extern int pthread_cancel (pthread_t __cancelthread);




extern void pthread_testcancel (void);
# 614 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer,
       void (*__routine) (void *),
       void *__arg) throw ();







extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer,
      int __execute) throw ();
# 635 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer,
      void (*__routine) (void *),
      void *__arg) throw ();
# 646 "/usr/include/pthread.h" 3 4
extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer,
       int __execute) throw ();





extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id) 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 *__restrict __newmask,
       __sigset_t *__restrict __oldmask)throw ();


extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
# 660 "/usr/include/pthread.h" 2 3 4
# 675 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) throw ();




extern void pthread_kill_other_threads_np (void) throw ();

}
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 2 3
# 1 "/usr/include/unistd.h" 1 3 4
# 28 "/usr/include/unistd.h" 3 4
extern "C" {
# 171 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 172 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 176 "/usr/include/unistd.h" 2 3 4
# 195 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 196 "/usr/include/unistd.h" 2 3 4
# 236 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;






typedef __socklen_t socklen_t;
# 256 "/usr/include/unistd.h" 3 4
extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));




extern int euidaccess (__const char *__name, int __type)
     throw () __attribute__ ((__nonnull__ (1)));
# 287 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 298 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) throw ();






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes);





extern ssize_t write (int __fd, __const void *__buf, size_t __n);
# 328 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset);






extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
         __off_t __offset);
# 356 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset);


extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
    __off64_t __offset);







extern int pipe (int __pipedes[2]) throw ();
# 378 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 390 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);






extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     throw ();






extern int usleep (__useconds_t __useconds);
# 414 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1)));



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 () __attribute__ ((__nonnull__ (1)));




extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern int fchdir (int __fd) throw ();
# 448 "/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 () __attribute__ ((__nonnull__ (1)));




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 () __attribute__ ((__nonnull__ (1)));




extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
     throw ();




extern int execv (__const char *__path, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));



extern int execle (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execl (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execvp (__const char *__file, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));




extern int execlp (__const char *__file, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));




extern int nice (int __inc) throw ();




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 26 "/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,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX,

    _PC_2_SYMLINKS

  };


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_IOV_MAX = _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,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG,


    _SC_LEVEL1_ICACHE_SIZE,

    _SC_LEVEL1_ICACHE_ASSOC,

    _SC_LEVEL1_ICACHE_LINESIZE,

    _SC_LEVEL1_DCACHE_SIZE,

    _SC_LEVEL1_DCACHE_ASSOC,

    _SC_LEVEL1_DCACHE_LINESIZE,

    _SC_LEVEL2_CACHE_SIZE,

    _SC_LEVEL2_CACHE_ASSOC,

    _SC_LEVEL2_CACHE_LINESIZE,

    _SC_LEVEL3_CACHE_SIZE,

    _SC_LEVEL3_CACHE_ASSOC,

    _SC_LEVEL3_CACHE_LINESIZE,

    _SC_LEVEL4_CACHE_SIZE,

    _SC_LEVEL4_CACHE_ASSOC,

    _SC_LEVEL4_CACHE_LINESIZE,



    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,

    _SC_RAW_SOCKETS

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,


    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _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,


    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LIBS,

    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V6_LP64_OFF64_CFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LIBS,

    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS

  };
# 531 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (__const char *__path, int __name)
     throw () __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) throw ();


extern long int sysconf (int __name) throw () __attribute__ ((__const__));



extern size_t confstr (int __name, char *__buf, size_t __len) throw ();




extern __pid_t getpid (void) throw ();


extern __pid_t getppid (void) throw ();




extern __pid_t getpgrp (void) throw ();
# 567 "/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 ();
# 593 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 610 "/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 int getresuid (__uid_t *__euid, __uid_t *__ruid, __uid_t *__suid);



extern int getresgid (__gid_t *__egid, __gid_t *__rgid, __gid_t *__sgid);



extern int setresuid (__uid_t __euid, __uid_t __ruid, __uid_t __suid);



extern int setresgid (__gid_t __egid, __gid_t __rgid, __gid_t __sgid);






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 () __attribute__ ((__nonnull__ (2)));



extern int isatty (int __fd) throw ();





extern int ttyslot (void) throw ();




extern int link (__const char *__from, __const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern int symlink (__const char *__from, __const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int readlink (__const char *__restrict __path, char *__restrict __buf,
       size_t __len) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));


extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) throw ();


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));




extern int setlogin (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
# 783 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 50 "/usr/include/getopt.h" 3 4
extern "C" {
# 59 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 73 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 152 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       throw ();
# 171 "/usr/include/getopt.h" 3 4
}
# 784 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));






extern int sethostname (__const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1)));



extern int sethostid (long int __id) throw ();





extern int getdomainname (char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1)));
extern int setdomainname (__const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1)));





extern int vhangup (void) throw ();


extern int revoke (__const char *__file) throw () __attribute__ ((__nonnull__ (1)));







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     throw () __attribute__ ((__nonnull__ (1)));





extern int acct (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));



extern char *getusershell (void) throw ();
extern void endusershell (void) throw ();
extern void setusershell (void) throw ();





extern int daemon (int __nochdir, int __noclose) throw ();






extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));



extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1)));
# 869 "/usr/include/unistd.h" 3 4
extern int fsync (int __fd);






extern long int gethostid (void);


extern void sync (void) throw ();




extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int truncate (__const char *__file, __off_t __length)
     throw () __attribute__ ((__nonnull__ (1)));
# 901 "/usr/include/unistd.h" 3 4
extern int truncate64 (__const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1)));




extern int ftruncate (int __fd, __off_t __length) throw ();
# 917 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw ();





extern int getdtablesize (void) throw ();
# 932 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw ();





extern void *sbrk (intptr_t __delta) throw ();
# 953 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 976 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len);
# 986 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len);
# 1007 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes) throw ();







extern char *crypt (__const char *__key, __const char *__salt)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));






extern void swab (__const void *__restrict __from, void *__restrict __to,
    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));







extern char *ctermid (char *__s) throw () __attribute__ ((__nonnull__ (1)));


}
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 2 3

typedef pthread_key_t __gthread_key_t;
typedef pthread_once_t __gthread_once_t;
typedef pthread_mutex_t __gthread_mutex_t;
typedef pthread_mutex_t __gthread_recursive_mutex_t;
# 63 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 3
#pragma weak pthread_once
#pragma weak pthread_key_create
#pragma weak pthread_key_delete
#pragma weak pthread_getspecific
#pragma weak pthread_setspecific
#pragma weak pthread_create

#pragma weak pthread_mutex_lock
#pragma weak pthread_mutex_trylock
#pragma weak pthread_mutex_unlock
#pragma weak pthread_mutexattr_init
#pragma weak pthread_mutexattr_settype
#pragma weak pthread_mutexattr_destroy

#pragma weak pthread_mutex_init
# 105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr = (void *) &pthread_create;
  return __gthread_active_ptr != 0;
}
# 467 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_once (__gthread_once_t *once, void (*func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (once, func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
  return pthread_key_create (key, dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t key)
{
  return pthread_key_delete (key);
}

static inline void *
__gthread_getspecific (__gthread_key_t key)
{
  return pthread_getspecific (key);
}

static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
  return pthread_setspecific (key, ptr);
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_lock (mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_trylock (mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (mutex);
  else
    return 0;
}
# 548 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
{
  return __gthread_mutex_lock (mutex);
}

static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
{
  return __gthread_mutex_trylock (mutex);
}

static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
{
  return __gthread_mutex_unlock (mutex);
}
# 105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/gthr.h" 2 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++io.h" 2 3

namespace std
{
  typedef __gthread_mutex_t __c_lock;


  typedef FILE __c_file;


  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;
  };
}
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cctype" 1 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cctype" 3
       
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 30 "/usr/include/ctype.h" 3 4
extern "C" {
# 48 "/usr/include/ctype.h" 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))
};
# 81 "/usr/include/ctype.h" 3 4
extern __const unsigned short int **__ctype_b_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __attribute__ ((__const));
# 96 "/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 tolower (int __c) throw ();


extern int toupper (int __c) throw ();








extern int isblank (int) throw ();






extern int isctype (int __c, int __mask) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();



extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 "/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 tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 "/usr/include/ctype.h" 3 4
}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cctype" 2 3
# 66 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cctype" 3
namespace std
{
  using ::isalnum;
  using ::isalpha;
  using ::iscntrl;
  using ::isdigit;
  using ::isgraph;
  using ::islower;
  using ::isprint;
  using ::ispunct;
  using ::isspace;
  using ::isupper;
  using ::isxdigit;
  using ::tolower;
  using ::toupper;
}
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stringfwd.h" 1 3
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stringfwd.h" 3
       
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stringfwd.h" 3



namespace std
{
  template<typename _Alloc>
    class allocator;

  template<class _CharT>
    struct char_traits;

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

  template<> struct char_traits<char>;

  typedef basic_string<char> string;


  template<> struct char_traits<wchar_t>;

  typedef basic_string<wchar_t> wstring;

}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 1 3
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 3
       
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 3



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ctime" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ctime" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ctime" 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ctime" 3
namespace std
{
  using ::clock_t;
  using ::time_t;
  using ::tm;

  using ::clock;
  using ::difftime;
  using ::mktime;
  using ::time;
  using ::asctime;
  using ::ctime;
  using ::gmtime;
  using ::localtime;
  using ::strftime;
}
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 40 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stdarg.h" 1 3 4
# 41 "/usr/include/wchar.h" 2 3 4







# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 93 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;



# 118 "/usr/include/wchar.h" 3 4
extern "C" {




struct tm;









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 () __attribute__ ((__pure__));

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




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 ();





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 ();








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 () __attribute__ ((__malloc__));




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

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





extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
     throw () __attribute__ ((__pure__));





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


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

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

extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));


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 () __attribute__ ((__pure__));




extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));




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





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


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


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 wchar_t *wmempcpy (wchar_t *__restrict __s1,
     __const wchar_t *__restrict __s2, 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 () __attribute__ ((__pure__));



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 ();






extern int wcwidth (wchar_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 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 ();






__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 ();
# 449 "/usr/include/wchar.h" 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 __npt,
          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 ();








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 ();








extern int fwide (__FILE *__fp, int __mode) throw ();






extern int fwprintf (__FILE *__restrict __stream,
       __const wchar_t *__restrict __format, ...)
                                                           ;




extern int wprintf (__const wchar_t *__restrict __format, ...)
                                                           ;

extern int swprintf (wchar_t *__restrict __s, size_t __n,
       __const wchar_t *__restrict __format, ...)
     throw () ;





extern int vfwprintf (__FILE *__restrict __s,
        __const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
                                                           ;




extern int vwprintf (__const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                           ;


extern int vswprintf (wchar_t *__restrict __s, size_t __n,
        __const wchar_t *__restrict __format,
        __gnuc_va_list __arg)
     throw () ;






extern int fwscanf (__FILE *__restrict __stream,
      __const wchar_t *__restrict __format, ...)
                                                          ;




extern int wscanf (__const wchar_t *__restrict __format, ...)
                                                          ;

extern int swscanf (__const wchar_t *__restrict __s,
      __const wchar_t *__restrict __format, ...)
     throw () ;











extern int vfwscanf (__FILE *__restrict __s,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
                                                          ;




extern int vwscanf (__const wchar_t *__restrict __format,
      __gnuc_va_list __arg)
                                                          ;

extern int vswscanf (__const wchar_t *__restrict __s,
       __const wchar_t *__restrict __format,
       __gnuc_va_list __arg)
     throw () ;










extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);





extern wint_t getwchar (void);






extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);





extern wint_t putwchar (wchar_t __wc);







extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
   __FILE *__restrict __stream);





extern int fputws (__const wchar_t *__restrict __ws,
     __FILE *__restrict __stream);






extern wint_t ungetwc (wint_t __wc, __FILE *__stream);

# 739 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);







extern wint_t fgetwc_unlocked (__FILE *__stream);







extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 765 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 775 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
     __FILE *__restrict __stream);







extern int fputws_unlocked (__const wchar_t *__restrict __ws,
       __FILE *__restrict __stream);







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







extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
     __const wchar_t *__restrict __format,
     __const struct tm *__restrict __tp,
     __locale_t __loc) throw ();
# 820 "/usr/include/wchar.h" 3 4
}
# 55 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 2 3
# 69 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 141 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 3
namespace std
{
  using ::wint_t;

  using ::btowc;
  using ::fgetwc;
  using ::fgetws;
  using ::fputwc;
  using ::fputws;
  using ::fwide;
  using ::fwprintf;
  using ::fwscanf;
  using ::getwc;
  using ::getwchar;
  using ::mbrlen;
  using ::mbrtowc;
  using ::mbsinit;
  using ::mbsrtowcs;
  using ::putwc;
  using ::putwchar;
  using ::swprintf;
  using ::swscanf;
  using ::ungetwc;
  using ::vfwprintf;

  using ::vfwscanf;

  using ::vswprintf;

  using ::vswscanf;

  using ::vwprintf;

  using ::vwscanf;

  using ::wcrtomb;
  using ::wcscat;
  using ::wcscmp;
  using ::wcscoll;
  using ::wcscpy;
  using ::wcscspn;
  using ::wcsftime;
  using ::wcslen;
  using ::wcsncat;
  using ::wcsncmp;
  using ::wcsncpy;
  using ::wcsrtombs;
  using ::wcsspn;
  using ::wcstod;

  using ::wcstof;

  using ::wcstok;
  using ::wcstol;
  using ::wcstoul;
  using ::wcsxfrm;
  using ::wctob;
  using ::wmemcmp;
  using ::wmemcpy;
  using ::wmemmove;
  using ::wmemset;
  using ::wprintf;
  using ::wscanf;

  using ::wcschr;

  inline wchar_t*
  wcschr(wchar_t* __p, wchar_t __c)
  { return wcschr(const_cast<const wchar_t*>(__p), __c); }

  using ::wcspbrk;

  inline wchar_t*
  wcspbrk(wchar_t* __s1, wchar_t* __s2)
  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }

  using ::wcsrchr;

  inline wchar_t*
  wcsrchr(wchar_t* __p, wchar_t __c)
  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }

  using ::wcsstr;

  inline wchar_t*
  wcsstr(wchar_t* __s1, const wchar_t* __s2)
  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }

  using ::wmemchr;

  inline wchar_t*
  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
}







namespace __gnu_cxx
{





  using ::wcstold;
# 258 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using __gnu_cxx::wcstold;
  using __gnu_cxx::wcstoll;
  using __gnu_cxx::wcstoull;
}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 2 3


# 1 "/usr/include/stdint.h" 1 3 4
# 28 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 49 "/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;
# 129 "/usr/include/stdint.h" 3 4
typedef unsigned int uintptr_t;
# 138 "/usr/include/stdint.h" 3 4
__extension__
typedef long long int intmax_t;
__extension__
typedef unsigned long long int uintmax_t;
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 2 3


namespace std
{
# 72 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 3
  typedef int64_t streamoff;





  typedef ptrdiff_t streamsize;

  template<typename _StateT>
    class fpos;
# 94 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 116 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }






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


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





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





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







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;
}
# 51 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/functexcept.h" 1 3
# 34 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/functexcept.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception_defines.h" 1 3
# 35 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/functexcept.h" 2 3

namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 2 3

namespace std
{
  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;
# 136 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iosfwd" 3
  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;


  typedef basic_ios<wchar_t> wios;
  typedef basic_streambuf<wchar_t> wstreambuf;
  typedef basic_istream<wchar_t> wistream;
  typedef basic_ostream<wchar_t> wostream;
  typedef basic_iostream<wchar_t> wiostream;
  typedef basic_stringbuf<wchar_t> wstringbuf;
  typedef basic_istringstream<wchar_t> wistringstream;
  typedef basic_ostringstream<wchar_t> wostringstream;
  typedef basic_stringstream<wchar_t> wstringstream;
  typedef basic_filebuf<wchar_t> wfilebuf;
  typedef basic_ifstream<wchar_t> wifstream;
  typedef basic_ofstream<wchar_t> wofstream;
  typedef basic_fstream<wchar_t> wfstream;


}
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception" 1 3
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception" 3
extern "C++" {

namespace std
{
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception" 3
  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__));
# 100 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception" 3
  bool uncaught_exception() throw();
}

namespace __gnu_cxx
{
# 115 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/exception" 3
  void __verbose_terminate_handler ();
}

}
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 1 3
# 66 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/climits" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/climits" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/climits" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 153 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 36 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 37 "/usr/include/bits/local_lim.h" 2 3 4
# 154 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/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
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 2 3 4
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/climits" 2 3
# 67 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 3
# 84 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 3
namespace std
{
  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  using ::abs;
  using ::atexit;
  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;
  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;


  inline long
  abs(long __i) { return labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }
}
# 140 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 3
namespace __gnu_cxx
{

  using ::lldiv_t;





  using ::_Exit;


  inline long long
  abs(long long __x) { return __x >= 0 ? __x : -__x; }

  inline long long
  llabs(long long __x) { return __x >= 0 ? __x : -__x; }


  inline lldiv_t
  div(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }

  inline lldiv_t
  lldiv(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
# 176 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;
}

namespace std
{

  using __gnu_cxx::lldiv_t;

  using __gnu_cxx::_Exit;
  using __gnu_cxx::abs;
  using __gnu_cxx::llabs;

  using __gnu_cxx::div;
  using __gnu_cxx::lldiv;

  using __gnu_cxx::atoll;
  using __gnu_cxx::strtof;
  using __gnu_cxx::strtoll;
  using __gnu_cxx::strtoull;
  using __gnu_cxx::strtold;
}
# 68 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/new" 1 3
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/new" 3
extern "C++" {

namespace std
{





  class bad_alloc : public exception
  {
  public:
    bad_alloc() throw() { }


    virtual ~bad_alloc() throw();
  };

  struct nothrow_t { };
  extern const nothrow_t nothrow;


  typedef void (*new_handler)();

  new_handler set_new_handler(new_handler) throw();
}
# 82 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/new" 3
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* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }


inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }

}
# 70 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_pair.h" 1 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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(), second() { }


      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); }
# 142 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_pair.h" 3
  template<class _T1, class _T2>
    inline pair<_T1, _T2>
    make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); }
}
# 72 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/type_traits.h" 1 3
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/type_traits.h" 3
       
# 53 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/type_traits.h" 3
# 90 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/type_traits.h" 3
struct __true_type {};
struct __false_type {};

template <class _Tp>
  struct __type_traits
  {
    typedef __true_type this_dummy_member_must_be_first;
# 114 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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;
  };




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;
  };




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 __gnu_cxx
{
  template<typename _Iterator, typename _Container>
    class __normal_iterator;
}

template<typename _Iterator, typename _Container>
  struct _Is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
          _Container> >
  {
    typedef __true_type _Normal;
  };
# 73 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_types.h" 1 3
# 67 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_types.h" 3
       
# 68 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_types.h" 3

namespace std
{
# 80 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_types.h" 3
  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 {};
# 104 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_types.h" 3
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct iterator
    {

      typedef _Category iterator_category;

      typedef _Tp value_type;

      typedef _Distance difference_type;

      typedef _Pointer pointer;

      typedef _Reference reference;
    };







  template<typename _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<typename _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<typename _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;
    };







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

}
# 74 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 1 3
# 67 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 3
       
# 68 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/concept_check.h" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/concept_check.h" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/concept_check.h" 3
# 69 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 2 3

namespace std
{
  template<typename _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<typename _RandomAccessIterator>
    inline typename iterator_traits<_RandomAccessIterator>::difference_type
    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
               random_access_iterator_tag)
    {

     

      return __last - __first;
    }
# 112 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    inline typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

      return std::__distance(__first, __last,
        std::__iterator_category(__first));
    }

  template<typename _InputIterator, typename _Distance>
    inline void
    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
    {

     
      while (__n--)
 ++__i;
    }

  template<typename _BidirectionalIterator, typename _Distance>
    inline void
    __advance(_BidirectionalIterator& __i, _Distance __n,
              bidirectional_iterator_tag)
    {

     

      if (__n > 0)
        while (__n--)
   ++__i;
      else
        while (__n++)
   --__i;
    }

  template<typename _RandomAccessIterator, typename _Distance>
    inline void
    __advance(_RandomAccessIterator& __i, _Distance __n,
              random_access_iterator_tag)
    {

     

      __i += __n;
    }
# 170 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

      std::__advance(__i, __n, std::__iterator_category(__i));
    }
}
# 75 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 1 3
# 68 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
namespace std
{
# 89 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class reverse_iterator
    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
        typename iterator_traits<_Iterator>::value_type,
        typename iterator_traits<_Iterator>::difference_type,
        typename iterator_traits<_Iterator>::pointer,
                      typename iterator_traits<_Iterator>::reference>
    {
    protected:
      _Iterator current;

    public:
      typedef _Iterator iterator_type;
      typedef typename iterator_traits<_Iterator>::difference_type
              difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

    public:






      reverse_iterator() : current() { }




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




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





      template<typename _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*()); }






      reverse_iterator&
      operator++()
      {
 --current;
 return *this;
      }






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






      reverse_iterator&
      operator--()
      {
 ++current;
 return *this;
      }






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






      reverse_iterator
      operator+(difference_type __n) const
      { return reverse_iterator(current - __n); }






      reverse_iterator&
      operator+=(difference_type __n)
      {
 current -= __n;
 return *this;
      }






      reverse_iterator
      operator-(difference_type __n) const
      { return reverse_iterator(current + __n); }






      reverse_iterator&
      operator-=(difference_type __n)
      {
 current += __n;
 return *this;
      }






      reference
      operator[](difference_type __n) const
      { return *(*this + __n); }
    };
# 275 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Iterator>
    inline bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }

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

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

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

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

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

  template<typename _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<typename _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); }
# 335 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container>
    class back_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit
      back_insert_iterator(_Container& __x) : container(&__x) { }
# 361 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_back(__value);
 return *this;
      }


      back_insert_iterator&
      operator*()
      { return *this; }


      back_insert_iterator&
      operator++()
      { return *this; }


      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 395 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 410 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container>
    class front_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;


      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
# 435 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_front(__value);
 return *this;
      }


      front_insert_iterator&
      operator*()
      { return *this; }


      front_insert_iterator&
      operator++()
      { return *this; }


      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 469 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 488 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container>
    class insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;
      typename _Container::iterator iter;

    public:

      typedef _Container container_type;





      insert_iterator(_Container& __x, typename _Container::iterator __i)
      : container(&__x), iter(__i) {}
# 530 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(const typename _Container::const_reference __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }


      insert_iterator&
      operator*()
      { return *this; }


      insert_iterator&
      operator++()
      { return *this; }


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 565 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  template<typename _Container, typename _Iterator>
    inline insert_iterator<_Container>
    inserter(_Container& __x, _Iterator __i)
    {
      return insert_iterator<_Container>(__x,
      typename _Container::iterator(__i));
    }
}

namespace __gnu_cxx
{







  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_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>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

      __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&
      operator++()
      {
 ++_M_current;
 return *this;
      }

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


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

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


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

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

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

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

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

      const _Iterator&
      base() const
      { return _M_current; }
    };
# 678 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_iterator.h" 3
  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 _Iterator, typename _Container>
    inline bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _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.base() != __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _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.base() < __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _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.base() > __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _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.base() <= __rhs.base(); }

  template<typename _Iterator, typename _Container>
    inline bool
    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _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.base() >= __rhs.base(); }

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





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

  template<typename _Iterator, typename _Container>
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
}
# 76 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/debug/debug.h" 1 3
# 272 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/debug/debug.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cassert" 1 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cassert" 3
       
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cassert" 2 3
# 273 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/debug/debug.h" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 275 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/debug/debug.h" 2 3



namespace __gnu_debug
{
  template<typename _Iterator, typename _Sequence>
    class _Safe_iterator;


  inline bool
  __check_singular_aux(const void*) { return false; }



  template<typename _Iterator>
    inline bool
    __check_singular(_Iterator& __x)
    { return __gnu_debug::__check_singular_aux(&__x); }


  template<typename _Tp>
    inline bool
    __check_singular(const _Tp* __ptr)
    { return __ptr == 0; }


  template<typename _Iterator, typename _Sequence>
    inline bool
    __check_singular(const _Safe_iterator<_Iterator, _Sequence>& __x)
    { return __x._M_singular(); }



  template<typename _Iterator>
    inline bool
    __check_dereferenceable(_Iterator&)
    { return true; }


  template<typename _Tp>
    inline bool
    __check_dereferenceable(const _Tp* __ptr)
    { return __ptr; }


  template<typename _Iterator, typename _Sequence>
    inline bool
    __check_dereferenceable(const _Safe_iterator<_Iterator, _Sequence>& __x)
    { return __x._M_dereferenceable(); }




  template<typename _RandomAccessIterator>
    inline bool
    __valid_range_aux2(const _RandomAccessIterator& __first,
         const _RandomAccessIterator& __last,
         std::random_access_iterator_tag)
    { return __last - __first >= 0; }





  template<typename _InputIterator>
    inline bool
    __valid_range_aux2(const _InputIterator&, const _InputIterator&,
         std::input_iterator_tag)
    { return true; }





  template<typename _Integral>
    inline bool
    __valid_range_aux(const _Integral&, const _Integral&, __true_type)
    { return true; }




  template<typename _InputIterator>
    inline bool
    __valid_range_aux(const _InputIterator& __first,
        const _InputIterator& __last, __false_type)
  {
    typedef typename std::iterator_traits<_InputIterator>::iterator_category
      _Category;
    return __gnu_debug::__valid_range_aux2(__first, __last, _Category());
  }






  template<typename _InputIterator>
    inline bool
    __valid_range(const _InputIterator& __first, const _InputIterator& __last)
    {
      typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
      return __gnu_debug::__valid_range_aux(__first, __last, _Integral());
    }


  template<typename _Iterator, typename _Sequence>
    inline bool
    __valid_range(const _Safe_iterator<_Iterator, _Sequence>& __first,
    const _Safe_iterator<_Iterator, _Sequence>& __last)
    { return __first._M_valid_range(__last); }





  template<typename _InputIterator>
    inline _InputIterator
    __check_valid_range(const _InputIterator& __first,
   const _InputIterator& __last)
    {
      ;
      return __first;
    }


  template<typename _CharT, typename _Integer>
    inline const _CharT*
    __check_string(const _CharT* __s, const _Integer& __n)
    {



      return __s;
    }


  template<typename _CharT>
    inline const _CharT*
    __check_string(const _CharT* __s)
    {



      return __s;
    }



  template<typename _InputIterator>
    inline bool
    __check_sorted_aux(const _InputIterator&, const _InputIterator&,
                       std::input_iterator_tag)
    { return true; }



  template<typename _ForwardIterator>
    inline bool
    __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
                       std::forward_iterator_tag)
    {
      if (__first == __last)
        return true;

      _ForwardIterator __next = __first;
      for (++__next; __next != __last; __first = __next, ++__next) {
        if (*__next < *__first)
          return false;
      }

      return true;
    }



  template<typename _InputIterator, typename _Predicate>
    inline bool
    __check_sorted_aux(const _InputIterator&, const _InputIterator&,
                       _Predicate, std::input_iterator_tag)
    { return true; }



  template<typename _ForwardIterator, typename _Predicate>
    inline bool
    __check_sorted_aux(_ForwardIterator __first, _ForwardIterator __last,
                       _Predicate __pred, std::forward_iterator_tag)
    {
      if (__first == __last)
        return true;

      _ForwardIterator __next = __first;
      for (++__next; __next != __last; __first = __next, ++__next) {
        if (__pred(*__next, *__first))
          return false;
      }

      return true;
    }


  template<typename _InputIterator>
    inline bool
    __check_sorted(const _InputIterator& __first, const _InputIterator& __last)
    {
      typedef typename std::iterator_traits<_InputIterator>::iterator_category
        _Category;
      return __gnu_debug::__check_sorted_aux(__first, __last, _Category());
    }

  template<typename _InputIterator, typename _Predicate>
    inline bool
    __check_sorted(const _InputIterator& __first, const _InputIterator& __last,
                   _Predicate __pred)
    {
      typedef typename std::iterator_traits<_InputIterator>::iterator_category
        _Category;
      return __gnu_debug::__check_sorted_aux(__first, __last, __pred,
          _Category());
    }




  template<typename _ForwardIterator, typename _Tp>
    inline bool
    __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
   const _Tp& __value)
    {
      while (__first != __last && *__first < __value)
 ++__first;
      while (__first != __last && !(*__first < __value))
 ++__first;
      return __first == __last;
    }


  template<typename _ForwardIterator, typename _Tp, typename _Pred>
    inline bool
    __check_partitioned(_ForwardIterator __first, _ForwardIterator __last,
   const _Tp& __value, _Pred __pred)
    {
      while (__first != __last && __pred(*__first, __value))
 ++__first;
      while (__first != __last && !__pred(*__first, __value))
 ++__first;
      return __first == __last;
    }
}
# 78 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 2 3

namespace std
{
# 90 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
      typedef typename iterator_traits<_ForwardIterator1>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator2>::value_type
 _ValueType2;


     

     

     

     


      const _ValueType1 __tmp = *__a;
      *__a = *__b;
      *__b = __tmp;
    }
# 123 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    {

     

      const _Tp __tmp = __a;
      __a = __b;
      __b = __tmp;
    }
# 148 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {

     

      if (__b < __a)
 return __b;
      return __a;
    }
# 170 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {

     

      if (__a < __b)
 return __b;
      return __a;
    }
# 192 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 212 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }







  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, input_iterator_tag)
    {
      for (; __first != __last; ++__result, ++__first)
 *__result = *__first;
      return __result;
    }

  template<typename _RandomAccessIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _OutputIterator __result, random_access_iterator_tag)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
          _Distance;
      for (_Distance __n = __last - __first; __n > 0; --__n)
 {
   *__result = *__first;
   ++__first;
   ++__result;
 }
      return __result;
    }

  template<typename _Tp>
    inline _Tp*
    __copy_trivial(const _Tp* __first, const _Tp* __last, _Tp* __result)
    {
      std::memmove(__result, __first, sizeof(_Tp) * (__last - __first));
      return __result + (__last - __first);
    }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_aux2(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, __false_type)
    { return std::__copy(__first, __last, __result,
    std::__iterator_category(__first)); }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_aux2(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, __true_type)
    { return std::__copy(__first, __last, __result,
    std::__iterator_category(__first)); }

  template<typename _Tp>
    inline _Tp*
    __copy_aux2(_Tp* __first, _Tp* __last, _Tp* __result, __true_type)
    { return std::__copy_trivial(__first, __last, __result); }

  template<typename _Tp>
    inline _Tp*
    __copy_aux2(const _Tp* __first, const _Tp* __last, _Tp* __result,
  __true_type)
    { return std::__copy_trivial(__first, __last, __result); }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_ni2(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result, __true_type)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType;
      typedef typename __type_traits<
 _ValueType>::has_trivial_assignment_operator _Trivial;
      return _OutputIterator(std::__copy_aux2(__first, __last, __result.base(),
           _Trivial()));
    }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_ni2(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result, __false_type)
    {
      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
      typedef typename __type_traits<
 _ValueType>::has_trivial_assignment_operator _Trivial;
      return std::__copy_aux2(__first, __last, __result, _Trivial());
    }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_ni1(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result, __true_type)
    {
      typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
      return std::__copy_ni2(__first.base(), __last.base(),
        __result, __Normal());
    }

  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    __copy_ni1(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result, __false_type)
    {
      typedef typename _Is_normal_iterator<_OutputIterator>::_Normal __Normal;
      return std::__copy_ni2(__first, __last, __result, __Normal());
    }
# 346 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

      ;

       typedef typename _Is_normal_iterator<_InputIterator>::_Normal __Normal;
       return std::__copy_ni1(__first, __last, __result, __Normal());
    }

  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
    inline _BidirectionalIterator2
    __copy_backward(_BidirectionalIterator1 __first,
      _BidirectionalIterator1 __last,
      _BidirectionalIterator2 __result,
      bidirectional_iterator_tag)
    {
      while (__first != __last)
        *--__result = *--__last;
      return __result;
    }

  template<typename _RandomAccessIterator, typename _BidirectionalIterator>
    inline _BidirectionalIterator
    __copy_backward(_RandomAccessIterator __first, _RandomAccessIterator __last,
      _BidirectionalIterator __result, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type __n;
      for (__n = __last - __first; __n > 0; --__n)
        *--__result = *--__last;
      return __result;
    }






  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
           typename _BoolType>
    struct __copy_backward_dispatch
    {
      static _BidirectionalIterator2
      copy(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
    _BidirectionalIterator2 __result)
      { return std::__copy_backward(__first, __last, __result,
        std::__iterator_category(__first)); }
    };

  template<typename _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;
 std::memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
 return __result - _Num;
      }
    };

  template<typename _Tp>
    struct __copy_backward_dispatch<const _Tp*, _Tp*, __true_type>
    {
      static _Tp*
      copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
      {
 return std::__copy_backward_dispatch<_Tp*, _Tp*, __true_type>
   ::copy(__first, __last, __result);
      }
    };

  template<typename _BI1, typename _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
 std::__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(std::__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 std::__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 std::__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 std::__copy_backward_output_normal_iterator(__first, __last,
        __result, __Normal());
    }
# 485 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template <typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      typedef typename _Is_normal_iterator<_BI1>::_Normal __Normal;
      return std::__copy_backward_input_normal_iterator(__first, __last,
       __result, __Normal());
    }
# 514 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {

     

      ;

      for ( ; __first != __last; ++__first)
 *__first = __value;
    }
# 538 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _OutputIterator, typename _Size, typename _Tp>
    _OutputIterator
    fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
    {

     

      for ( ; __n > 0; --__n, ++__first)
 *__first = __value;
      return __first;
    }


  inline void
  fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
  {
    ;
    const unsigned char __tmp = __c;
    std::memset(__first, __tmp, __last - __first);
  }

  inline void
  fill(signed char* __first, signed char* __last, const signed char& __c)
  {
    ;
    const signed char __tmp = __c;
    std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
  }

  inline void
  fill(char* __first, char* __last, const char& __c)
  {
    ;
    const char __tmp = __c;
    std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
  }

  template<typename _Size>
    inline unsigned char*
    fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }

  template<typename _Size>
    inline signed char*
    fill_n(char* __first, _Size __n, const signed char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }

  template<typename _Size>
    inline char*
    fill_n(char* __first, _Size __n, const char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }
# 612 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2)
    {

     
     
     

     

      ;

      while (__first1 != __last1 && *__first1 == *__first2)
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 648 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {

     
     
      ;

      while (__first1 != __last1 && __binary_pred(*__first1, *__first2))
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 678 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    inline bool
    equal(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2)
    {

     
     
     


      ;

      for ( ; __first1 != __last1; ++__first1, ++__first2)
 if (!(*__first1 == *__first2))
   return false;
      return true;
    }
# 710 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    inline bool
    equal(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2,
   _BinaryPredicate __binary_pred)
    {

     
     
      ;

      for ( ; __first1 != __last1; ++__first1, ++__first2)
 if (!__binary_pred(*__first1, *__first2))
   return false;
      return true;
    }
# 742 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     

     

      ;
      ;

      for (;__first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
 {
   if (*__first1 < *__first2)
     return true;
   if (*__first2 < *__first1)
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }
# 779 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _Compare __comp)
    {

     
     
      ;
      ;

      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 = std::memcmp(__first1, __first2,
         std::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 std::lexicographical_compare((const signed char*) __first1,
     (const signed char*) __last1,
     (const signed char*) __first2,
     (const signed char*) __last2);






  }

}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 2 3


namespace __gnu_cxx
{
# 62 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 3
  template <class _CharT>
    struct _Char_types
    {
      typedef unsigned long int_type;
      typedef std::streampos pos_type;
      typedef std::streamoff off_type;
      typedef std::mbstate_t state_type;
    };
# 86 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;
      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type 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, std::size_t __n);

      static std::size_t
      length(const char_type* __s);

      static const char_type*
      find(const char_type* __s, std::size_t __n, const char_type& __a);

      static char_type*
      move(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      copy(char_type* __s1, const char_type* __s2, std::size_t __n);

      static char_type*
      assign(char_type* __s, std::size_t __n, char_type __a);

      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>(__c); }

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

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

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

  template<typename _CharT>
    int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      return static_cast<_CharT*>(std::memmove(__s1, __s2,
            __n * sizeof(char_type)));
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      std::copy(__s2, __s2 + __n, __s1);
      return __s1;
    }

  template<typename _CharT>
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {
      std::fill_n(__s, __n, __a);
      return __s;
    }
}

namespace std
{
# 224 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/char_traits.h" 3
  template<class _CharT>
    struct char_traits
    : public __gnu_cxx::char_traits<_CharT>
    { };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef 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 int_type
      eof() { return static_cast<int_type>((-1)); }

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




  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t char_type;
      typedef wint_t int_type;
      typedef streamoff off_type;
      typedef wstreampos pos_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 wmemcmp(__s1, __s2, __n); }

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

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return wmemchr(__s, __a, __n); }

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

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

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return wmemset(__s, __a, __n); }

      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 int_type
      eof() { return static_cast<int_type>((0xffffffffu)); }

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


  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); }
    };
}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/localefwd.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/localefwd.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/localefwd.h" 3




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/functexcept.h" 1 3
# 36 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/functexcept.h" 3
namespace std
{

  void
  __throw_bad_exception(void);


  void
  __throw_bad_alloc(void);


  void
  __throw_bad_cast(void);

  void
  __throw_bad_typeid(void);


  void
  __throw_logic_error(const char* __s);

  void
  __throw_domain_error(const char* __s);

  void
  __throw_invalid_argument(const char* __s);

  void
  __throw_length_error(const char* __s);

  void
  __throw_out_of_range(const char* __s);

  void
  __throw_runtime_error(const char* __s);

  void
  __throw_range_error(const char* __s);

  void
  __throw_overflow_error(const char* __s);

  void
  __throw_underflow_error(const char* __s);


  void
  __throw_ios_failure(const char* __s);
}
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/localefwd.h" 2 3

namespace std
{

  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<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  class __enc_traits;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, 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<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;

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);

  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
}
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/atomicity.h" 1 3
# 33 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/atomicity.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/atomic_word.h" 1 3
# 33 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 34 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/atomicity.h" 2 3

namespace __gnu_cxx
{
  _Atomic_word
  __attribute__ ((__unused__))
  __exchange_and_add(volatile _Atomic_word* __mem, int __val);

  void
  __attribute__ ((__unused__))
  __atomic_add(volatile _Atomic_word* __mem, int __val);
}
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 3




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 1 3
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
       
# 53 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/allocator.h" 1 3
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/allocator.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++allocator.h" 1 3
# 34 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++allocator.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ext/new_allocator.h" 1 3
# 35 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ext/new_allocator.h" 3
namespace __gnu_cxx
{
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ext/new_allocator.h" 3
  template<typename _Tp>
    class new_allocator
    {
    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<typename _Tp1>
        struct rebind
        { typedef new_allocator<_Tp1> other; };

      new_allocator() throw() { }

      new_allocator(const new_allocator&) throw() { }

      template<typename _Tp1>
        new_allocator(const new_allocator<_Tp1>&) throw() { }

      ~new_allocator() throw() { }

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

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



      pointer
      allocate(size_type __n, const void* = 0)
      { return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); }


      void
      deallocate(pointer __p, size_type)
      { ::operator delete(__p); }

      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<typename _Tp>
    inline bool
    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
    { return true; }

  template<typename _Tp>
    inline bool
    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
    { return false; }
}
# 35 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/c++allocator.h" 2 3
# 53 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/allocator.h" 2 3

namespace std
{
  template<typename _Tp>
    class allocator;

  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<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };
    };






  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {
   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<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };

      allocator() throw() { }

      allocator(const allocator& a) throw()
      : __gnu_cxx::new_allocator<_Tp>(a) { }

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

      ~allocator() throw() { }


    };

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

  template<typename _T1, typename _T2>
    inline bool
    operator!=(const allocator<_T1>&, const allocator<_T2>&)
    { return false; }





  extern template class allocator<char>;
  extern template class allocator<wchar_t>;




}
# 56 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_construct.h" 1 3
# 67 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_construct.h" 3
namespace std
{






  template<typename _T1, typename _T2>
    inline void
    _Construct(_T1* __p, const _T2& __value)
    {


      ::new(static_cast<void*>(__p)) _T1(__value);
    }







  template<typename _T1>
    inline void
    _Construct(_T1* __p)
    {


      ::new(static_cast<void*>(__p)) _T1();
    }






  template<typename _Tp>
    inline void
    _Destroy(_Tp* __pointer)
    { __pointer->~_Tp(); }
# 116 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
    __false_type)
    { for ( ; __first != __last; ++__first) std::_Destroy(&*__first); }
# 131 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
    { }
# 143 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
      typedef typename __type_traits<_Value_type>::has_trivial_destructor
                       _Has_trivial_destructor;

      std::__destroy_aux(__first, __last, _Has_trivial_destructor());
    }
}
# 57 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 1 3
# 66 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 3
namespace std
{

  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result,
        __true_type)
    { return std::copy(__first, __last, __result); }

  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result,
        __false_type)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for ( ; __first != __last; ++__first, ++__cur)
     std::_Construct(&*__cur, *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }
# 105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      return std::__uninitialized_copy_aux(__first, __last, __result,
        _Is_POD());
    }

  inline char*
  uninitialized_copy(const char* __first, const char* __last, char* __result)
  {
    std::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)
  {
    std::memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
    return __result + (__last - __first);
  }



  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_fill_aux(_ForwardIterator __first,
        _ForwardIterator __last,
        const _Tp& __x, __true_type)
    { std::fill(__first, __last, __x); }

  template<typename _ForwardIterator, typename _Tp>
    void
    __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x, __false_type)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for ( ; __cur != __last; ++__cur)
     std::_Construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur);
   throw;
 }
    }
# 167 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      std::__uninitialized_fill_aux(__first, __last, __x, _Is_POD());
    }



  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline _ForwardIterator
    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
          const _Tp& __x, __true_type)
    { return std::fill_n(__first, __n, __x); }

  template<typename _ForwardIterator, typename _Size, typename _Tp>
    _ForwardIterator
    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
          const _Tp& __x, __false_type)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for ( ; __n > 0; --__n, ++__cur)
     std::_Construct(&*__cur, __x);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__first, __cur);
   throw;
 }
    }
# 213 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline _ForwardIterator
    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
      typedef typename __type_traits<_ValueType>::is_POD_type _Is_POD;
      return std::__uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
    }
# 230 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_copy(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result)
    {
      _ForwardIterator __mid = std::uninitialized_copy(__first1, __last1,
             __result);
      try
 {
   return std::uninitialized_copy(__first2, __last2, __mid);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Tp, typename _InputIterator>
    inline _ForwardIterator
    __uninitialized_fill_copy(_ForwardIterator __result, _ForwardIterator __mid,
         const _Tp& __x, _InputIterator __first,
         _InputIterator __last)
    {
      std::uninitialized_fill(__result, __mid, __x);
      try
 {
   return std::uninitialized_copy(__first, __last, __mid);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x)
    {
      _ForwardIterator __mid2 = std::uninitialized_copy(__first1, __last1,
       __first2);
      try
 {
   std::uninitialized_fill(__mid2, __last2, __x);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2);
   throw;
 }
    }

}
# 59 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_raw_storage_iter.h" 1 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_raw_storage_iter.h" 3
namespace std
{




  template <class _ForwardIterator, class _Tp>
    class raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _ForwardIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_ForwardIterator __x)
      : _M_iter(__x) {}

      raw_storage_iterator&
      operator*() { return *this; }

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_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;
      }
    };
}
# 60 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 2 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 1 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 3
       
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 3
# 150 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 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
  };
# 192 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 3
  struct __numeric_limits_base
  {


    static const bool is_specialized = false;




    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 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 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;
  };
# 285 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static _Tp min() throw() { return static_cast<_Tp>(0); }

      static _Tp max() throw() { return static_cast<_Tp>(0); }


      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }

      static _Tp round_error() throw() { return static_cast<_Tp>(0); }

      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); }
    };



  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 = 1;
      static const int digits10 = 0;
      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 false; }
      static bool round_error() throw()
      { return false; }

      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 false; }
      static bool quiet_NaN() throw()
      { return false; }
      static bool signaling_NaN() throw()
      { return false; }
      static bool denorm_min() throw()
      { return false; }

      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<char>
    {
      static const bool is_specialized = true;

      static char min() throw()
      { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
      static char max() throw()
      { return (((char)(-1) < 0) ? ((char)1 << (sizeof(char) * 8 - ((char)(-1) < 0))) - 1 : ~(char)0); }

      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);
      static const bool is_signed = ((char)(-1) < 0);
      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 char(); }
      static char quiet_NaN() throw()
      { return char(); }
      static char signaling_NaN() throw()
      { return char(); }
      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 = 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<signed char>
    {
      static const bool is_specialized = true;

      static signed char min() throw()
      { return -127 - 1; }
      static signed char max() throw()
      { return 127; }

      static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136);
      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 = 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<unsigned char>
    {
      static const bool is_specialized = true;

      static unsigned char min() throw()
      { return 0; }
      static unsigned char max() throw()
      { return 127 * 2U + 1; }

      static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136);
      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<wchar_t>
    {
      static const bool is_specialized = true;

      static wchar_t min() throw()
      { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
      static wchar_t max() throw()
      { return (((wchar_t)(-1) < 0) ? ((wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0))) - 1 : ~(wchar_t)0); }

      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136);
      static const bool is_signed = ((wchar_t)(-1) < 0);
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static wchar_t epsilon() throw()
      { return 0; }
      static wchar_t 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 wchar_t infinity() throw()
      { return wchar_t(); }
      static wchar_t quiet_NaN() throw()
      { return wchar_t(); }
      static wchar_t signaling_NaN() throw()
      { return wchar_t(); }
      static wchar_t denorm_min() throw()
      { return wchar_t(); }

      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 = (sizeof(short) * 8 - ((short)(-1) < 0));
      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);
      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 short(); }
      static short quiet_NaN() throw()
      { return short(); }
      static short signaling_NaN() throw()
      { return short(); }
      static short denorm_min() throw()
      { return short(); }

      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<unsigned short>
    {
      static const bool is_specialized = true;

      static unsigned short min() throw()
      { return 0; }
      static unsigned short max() throw()
      { return 32767 * 2U + 1; }

      static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136);
      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 = (sizeof(int) * 8 - ((int)(-1) < 0));
      static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136);
      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 = 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<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 = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136);
      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 = 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<long>
    {
      static const bool is_specialized = true;

      static long min() throw()
      { return -2147483647L - 1; }
      static long max() throw()
      { return 2147483647L; }

      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136);
      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 = 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<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 = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136);
      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 = 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<long long>
    {
      static const bool is_specialized = true;

      static long long min() throw()
      { return -9223372036854775807LL - 1; }
      static long long max() throw()
      { return 9223372036854775807LL; }

      static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136);
      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 long epsilon() throw()
      { return 0; }
      static long 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 long infinity() throw()
      { return static_cast<long long>(0); }
      static long long quiet_NaN() throw()
      { return static_cast<long long>(0); }
      static long long signaling_NaN() throw()
      { return static_cast<long long>(0); }
      static long long denorm_min() throw()
      { return static_cast<long long>(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<unsigned long long>
    {
      static const bool is_specialized = true;

      static unsigned long long min() throw()
      { return 0; }
      static unsigned long long max() throw()
      { return 9223372036854775807LL * 2ULL + 1; }

      static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136);
      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 long epsilon() throw()
      { return 0; }
      static unsigned long 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 long infinity() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long quiet_NaN() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long signaling_NaN() throw()
      { return static_cast<unsigned long long>(0); }
      static unsigned long long denorm_min() throw()
      { return static_cast<unsigned long long>(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<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 = 6;
      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-7F; }
      static float round_error() throw()
      { return 0.5F; }

      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 = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = 1.40129846e-45F ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static float infinity() throw()
      { return __builtin_huge_valf (); }
      static float quiet_NaN() throw()
      { return __builtin_nanf (""); }
      static float signaling_NaN() throw()
      { return __builtin_nansf (""); }
      static float denorm_min() throw()
      { return 1.40129846e-45F; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      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_to_nearest;
    };





  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 0.5; }

      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 = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = 4.9406564584124654e-324 ? denorm_present : denorm_absent;
      static const bool has_denorm_loss = false;

      static double infinity() throw()
      { return __builtin_huge_val(); }
      static double quiet_NaN() throw()
      { return __builtin_nan (""); }
      static double signaling_NaN() throw()
      { return __builtin_nans (""); }
      static double denorm_min() throw()
      { return 4.9406564584124654e-324; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      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_to_nearest;
    };





  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 = 18;
      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 0.5L; }

      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 = 1;
      static const bool has_quiet_NaN = 1;
      static const bool has_signaling_NaN = has_quiet_NaN;
      static const float_denorm_style has_denorm
 = 3.64519953188247460253e-4951L ? denorm_present : denorm_absent;
      static const bool has_denorm_loss
 = false;

      static long double infinity() throw()
      { return __builtin_huge_vall (); }
      static long double quiet_NaN() throw()
      { return __builtin_nanl (""); }
      static long double signaling_NaN() throw()
      { return __builtin_nansl (""); }
      static long double denorm_min() throw()
      { return 3.64519953188247460253e-4951L; }

      static const bool is_iec559
 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
      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_to_nearest;
    };





}
# 62 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 2 3

namespace std
{
# 73 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    __get_temporary_buffer(ptrdiff_t __len, _Tp*)
    {
      const ptrdiff_t __max = numeric_limits<ptrdiff_t>::max() / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       nothrow));
   if (__tmp != 0)
     return pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len /= 2;
 }
      return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 109 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
  template<typename _Tp>
    inline pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len)
    { return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); }
# 121 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
  template<typename _Tp>
    void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p, nothrow); }
# 133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    };
# 174 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 200 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 212 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 223 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 240 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 260 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      ~auto_ptr() { delete _M_ptr; }
# 270 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      element_type&
      operator*() const throw()
      {
 ;
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 ;
 return _M_ptr;
      }
# 300 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 314 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 329 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 350 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/memory" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }

  };
}
# 49 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 2 3



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 1 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
namespace std
{
# 101 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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;
    };
# 133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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>
    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; }
    };
# 195 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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; }
    };
# 256 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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; }
    };
# 311 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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); }
# 391 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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); }



      typename _Operation::result_type
      operator()(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); }



      typename _Operation::result_type
      operator()(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));
    }
# 480 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_function.h" 3
  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 _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; }
    };
# 590 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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;
    };



  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); }



}
# 53 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3




namespace std
{
# 109 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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 __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
                                                            const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;

    private:
# 144 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      struct _Rep_base
      {
 size_type _M_length;
 size_type _M_capacity;
 _Atomic_word _M_refcount;
      };

      struct _Rep : _Rep_base
      {

 typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
# 169 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
 static const size_type _S_max_size;
 static const _CharT _S_terminal;



        static size_type _S_empty_rep_storage[];

        static _Rep&
        _S_empty_rep()
        { return *reinterpret_cast<_Rep*>(&_S_empty_rep_storage); }

        bool
 _M_is_leaked() const
        { return this->_M_refcount < 0; }

        bool
 _M_is_shared() const
        { return this->_M_refcount > 0; }

        void
 _M_set_leaked()
        { this->_M_refcount = -1; }

        void
 _M_set_sharable()
        { this->_M_refcount = 0; }

 _CharT*
 _M_refdata() throw()
 { return reinterpret_cast<_CharT*>(this + 1); }

 _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_type, size_type, const _Alloc&);

 void
 _M_dispose(const _Alloc& __a)
 {
   if (__builtin_expect(this != &_S_empty_rep(), false))
     if (__gnu_cxx::__exchange_and_add(&this->_M_refcount, -1) <= 0)
       _M_destroy(__a);
 }

 void
 _M_destroy(const _Alloc&) throw();

 _CharT*
 _M_refcopy() throw()
 {
   if (__builtin_expect(this != &_S_empty_rep(), false))
            __gnu_cxx::__atomic_add(&this->_M_refcount, 1);
   return _M_refdata();
 }

 _CharT*
 _M_clone(const _Alloc&, size_type __res = 0);
      };


      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;

      _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();
      }

      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range((__s));
 return __pos;
      }


      size_type
      _M_limit(size_type __pos, size_type __off) const
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }



      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 _Rep::_S_empty_rep(); }

    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);
# 384 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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 __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc());




      ~basic_string()
      { _M_rep()->_M_dispose(this->get_allocator()); }





      basic_string&
      operator=(const basic_string& __str)
      {
 this->assign(__str);
 return *this;
      }





      basic_string&
      operator=(const _CharT* __s)
      {
 this->assign(__s);
 return *this;
      }
# 445 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }






      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; }
# 553 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 566 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      void
      resize(size_type __n) { this->resize(__n, _CharT()); }





      size_type
      capacity() const { return _M_rep()->_M_capacity; }
# 593 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      void
      reserve(size_type __res_arg = 0);




      void
      clear() { _M_mutate(0, this->size(), 0); }




      bool
      empty() const { return this->size() == 0; }
# 619 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 636 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {
 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 654 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("basic_string::at"));
 return _M_data()[__n];
      }
# 673 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range(("basic_string::at"));
 _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);
# 727 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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));
      }
# 759 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c)
      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
# 771 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_iend(), _M_iend(), __first, __last); }





      void
      push_back(_CharT __c)
      { _M_replace_aux(this->size(), size_type(0), size_type(1), __c); }






      basic_string&
      assign(const basic_string& __str);
# 804 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n)
      { return this->assign(__str._M_data()
       + __str._M_check(__pos, "basic_string::assign"),
       __str._M_limit(__pos, __n)); }
# 820 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 832 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return this->assign(__s, traits_type::length(__s));
      }
# 848 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 860 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
# 877 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }
# 892 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      template<class _InputIterator>
        void insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }
# 907 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
# 929 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str,
      size_type __pos2, size_type __n)
      { return this->insert(__pos1, __str._M_data()
       + __str._M_check(__pos2, "basic_string::insert"),
       __str._M_limit(__pos2, __n)); }
# 952 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 970 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->insert(__pos, __s, traits_type::length(__s));
      }
# 993 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
         size_type(0), __n, __c); }
# 1010 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      iterator
      insert(iterator __p, _CharT __c)
      {
 ;
 const size_type __pos = __p - _M_ibegin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 _M_rep()->_M_set_leaked();
 return this->_M_ibegin() + __pos;
      }
# 1034 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      { return _M_replace_safe(_M_check(__pos, "basic_string::erase"),
          _M_limit(__pos, __n), __null, size_type(0)); }
# 1047 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      iterator
      erase(iterator __position)
      {
 ;

 const size_type __pos = __position - _M_ibegin();
 _M_replace_safe(__pos, size_type(1), __null, size_type(0));
 _M_rep()->_M_set_leaked();
 return _M_ibegin() + __pos;
      }
# 1067 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      iterator
      erase(iterator __first, iterator __last)
      {
 ;

        const size_type __pos = __first - _M_ibegin();
 _M_replace_safe(__pos, __last - __first, __null, size_type(0));
 _M_rep()->_M_set_leaked();
 return _M_ibegin() + __pos;
      }
# 1094 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 1116 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2)
      { return this->replace(__pos1, __n1, __str._M_data()
        + __str._M_check(__pos2, "basic_string::replace"),
        __str._M_limit(__pos2, __n2)); }
# 1140 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2);
# 1159 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
 ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 1182 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
         _M_limit(__pos, __n1), __n2, __c); }
# 1200 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 1218 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
      {
 ;

 return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
      }
# 1239 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      {
 ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 1260 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
      {
 ;

 return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
      }
# 1282 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        replace(iterator __i1, iterator __i2,
  _InputIterator __k1, _InputIterator __k2)
        {
   ;

   ;
   typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
   return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
 }



      basic_string&
        replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
        {
   ;

   ;
   return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
          __k1, __k2 - __k1);
 }

      basic_string&
        replace(iterator __i1, iterator __i2,
  const _CharT* __k1, const _CharT* __k2)
        {
   ;

   ;
   return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
          __k1, __k2 - __k1);
 }

      basic_string&
        replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
        {
   ;

   ;
   return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
          __k1.base(), __k2 - __k1);
 }

      basic_string&
        replace(iterator __i1, iterator __i2,
  const_iterator __k1, const_iterator __k2)
        {
   ;

   ;
   return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
          __k1.base(), __k2 - __k1);
 }

    private:
      template<class _Integer>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
       _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 basic_string&
 _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
       _InputIterator __k2, __false_type);

      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c)
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error(("basic_string::_M_replace_aux"));
 _M_mutate(__pos1, __n1, __n2);
 if (__n2 == 1)
   _M_data()[__pos1] = __c;
 else if (__n2)
   traits_type::assign(_M_data() + __pos1, __n2, __c);
 return *this;
      }

      basic_string&
      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
        size_type __n2)
      {
 _M_mutate(__pos1, __n1, __n2);
 if (__n2 == 1)
   _M_data()[__pos1] = *__s;
 else if (__n2)
   traits_type::copy(_M_data() + __pos1, __s, __n2);
 return *this;
      }



      template<class _InIterator>
        static _CharT*
        _S_construct_aux(_InIterator __beg, _InIterator __end,
    const _Alloc& __a, __false_type)
 {
          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
          return _S_construct(__beg, __end, __a, _Tag());
 }

      template<class _InIterator>
        static _CharT*
        _S_construct_aux(_InIterator __beg, _InIterator __end,
    const _Alloc& __a, __true_type)
 { return _S_construct(static_cast<size_type>(__beg),
         static_cast<value_type>(__end), __a); }

      template<class _InIterator>
        static _CharT*
        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
 {
   typedef typename _Is_integer<_InIterator>::_Integral _Integral;
   return _S_construct_aux(__beg, __end, __a, _Integral());
        }


      template<class _InIterator>
        static _CharT*
         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
        input_iterator_tag);



      template<class _FwdIterator>
        static _CharT*
        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
       forward_iterator_tag);

      static _CharT*
      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);

    public:
# 1431 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1441 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1451 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      const _CharT*
      c_str() const { return _M_data(); }







      const _CharT*
      data() const { return _M_data(); }




      allocator_type
      get_allocator() const { return _M_dataplus; }
# 1480 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1493 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      { return this->find(__str.data(), __pos, __str.size()); }
# 1507 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 1524 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const;
# 1537 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      { return this->rfind(__str.data(), __pos, __str.size()); }
# 1552 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1565 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 1582 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const;
# 1595 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 1610 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1623 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 1642 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }
# 1656 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 1671 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1684 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 1703 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }
# 1717 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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()); }
# 1732 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const;
# 1746 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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));
      }
# 1763 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;
# 1776 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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()); }
# 1792 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const;
# 1805 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      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));
      }
# 1822 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;
# 1837 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 1853 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = __size - __osize;
 return __r;
      }
# 1881 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 1903 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 1918 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 1938 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 1961 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
  };


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()
    : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
# 1979 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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;
    }
# 2050 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2087 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2124 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2161 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2198 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2235 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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; }
# 2272 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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); }
# 2289 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
        basic_string<_CharT, _Traits, _Alloc>& __str);
# 2303 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const basic_string<_CharT, _Traits, _Alloc>& __str);
# 2321 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  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);
# 2338 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str);
}
# 54 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 2 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/algorithm" 1 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/algorithm" 3
       
# 65 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/algorithm" 3




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 1 3
# 64 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 1 3
# 65 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
namespace std
{



  template<typename _RandomAccessIterator, typename _Distance>
    bool
    __is_heap(_RandomAccessIterator __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<typename _RandomAccessIterator, typename _Distance,
           typename _StrictWeakOrdering>
    bool
    __is_heap(_RandomAccessIterator __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<typename _RandomAccessIterator>
    bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
    bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _StrictWeakOrdering __comp)
    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }



  template<typename _RandomAccessIterator, typename _Distance, typename _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;
    }
# 139 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;


      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), _ValueType(*(__last - 1)));
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
     typename _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;
    }
# 187 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;
      ;

      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), _ValueType(*(__last - 1)), __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value)
    {
      const _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;
 }
      std::__push_heap(__first, __holeIndex, __topIndex, __value);
    }

  template<typename _RandomAccessIterator, typename _Tp>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Tp __value)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      *__result = *__first;
      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
    __value);
    }
# 251 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::__pop_heap(__first, __last - 1, __last - 1,
        _ValueType(*(__last - 1)));
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _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;
 }
      std::__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
    }

  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Tp __value, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      *__result = *__first;
      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
    __value, __comp);
    }
# 317 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;

      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      std::__pop_heap(__first, __last - 1, __last - 1,
        _ValueType(*(__last - 1)), __comp);
    }
# 342 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

     
      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   std::__adjust_heap(__first, __parent, __len,
        _ValueType(*(__first + __parent)));
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 382 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;


     

      ;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   std::__adjust_heap(__first, __parent, __len,
        _ValueType(*(__first + __parent)), __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 420 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;


      while (__last - __first > 1)
 std::pop_heap(__first, __last--);
    }
# 446 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;

      while (__last - __first > 1)
 std::pop_heap(__first, __last--, __comp);
    }

}
# 65 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_tempbuf.h" 1 3
# 66 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_tempbuf.h" 3
namespace std
{







  template<typename _ForwardIterator, typename _Tp>
    class _Temporary_buffer
    {

     

 public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef pointer iterator;
      typedef ptrdiff_t size_type;

    protected:
      size_type _M_original_len;
      size_type _M_len;
      pointer _M_buffer;

      void
      _M_initialize_buffer(const _Tp&, __true_type) { }

      void
      _M_initialize_buffer(const _Tp& val, __false_type)
      { std::uninitialized_fill_n(_M_buffer, _M_len, val); }

    public:

      size_type
      size() const
      { return _M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_buffer; }


      iterator
      end()
      { return _M_buffer + _M_len; }





      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);

      ~_Temporary_buffer()
      {
 std::_Destroy(_M_buffer, _M_buffer + _M_len);
 std::return_temporary_buffer(_M_buffer);
      }

    private:

      _Temporary_buffer(const _Temporary_buffer&);

      void
      operator=(const _Temporary_buffer&);
    };


  template<typename _ForwardIterator, typename _Tp>
    _Temporary_buffer<_ForwardIterator, _Tp>::
    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
    : _M_original_len(std::distance(__first, __last)),
      _M_len(0), _M_buffer(0)
    {

      typedef typename __type_traits<_Tp>::has_trivial_default_constructor
       _Trivial;

      try
 {
   pair<pointer, size_type> __p(get_temporary_buffer<
           value_type>(_M_original_len));
   _M_buffer = __p.first;
   _M_len = __p.second;
   if (_M_len > 0)
     _M_initialize_buffer(*__first, _Trivial());
 }
      catch(...)
 {
   std::return_temporary_buffer(_M_buffer);
   _M_buffer = 0;
   _M_len = 0;
   throw;
 }
    }
}
# 66 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 2 3




namespace std
{
# 84 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _Tp>
    inline const _Tp&
    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
    {

     
      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;
    }
# 118 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
    {

     
      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;
    }
# 150 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {

     
      ;
      for ( ; __first != __last; ++__first)
 __f(*__first);
      return __f;
    }






  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
  const _Tp& __val, input_iterator_tag)
    {
      while (__first != __last && !(*__first == __val))
 ++__first;
      return __first;
    }






  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !__pred(*__first))
 ++__first;
      return __first;
    }






  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    find(_RandomAccessIterator __first, _RandomAccessIterator __last,
  const _Tp& __val, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::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<typename _RandomAccessIterator, typename _Predicate>
    _RandomAccessIterator
    find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::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;
 }
    }
# 304 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
  const _Tp& __val)
    {

     
     

      ;
      return std::find(__first, __last, __val,
         std::__iterator_category(__first));
    }
# 326 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {

     
     

      ;
      return std::find_if(__first, __last, __pred,
     std::__iterator_category(__first));
    }
# 348 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while(++__next != __last)
 {
   if (*__first == *__next)
     return __first;
   __first = __next;
 }
      return __last;
    }
# 379 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {

     
     


      ;
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while(++__next != __last)
 {
   if (__binary_pred(*__first, *__next))
     return __first;
   __first = __next;
 }
      return __last;
    }
# 410 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {

     
     

     
      ;
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for ( ; __first != __last; ++__first)
 if (*__first == __value)
   ++__n;
      return __n;
    }
# 435 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {

     
     

      ;
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for ( ; __first != __last; ++__first)
 if (__pred(*__first))
   ++__n;
      return __n;
    }
# 474 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;

      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2)
 return std::find(__first1, __last1, *__first2);


      _ForwardIterator2 __p1, __p;
      __p1 = __first2; ++__p1;
      _ForwardIterator1 __current = __first1;

      while (__first1 != __last1)
 {
   __first1 = std::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;
    }
# 545 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {

     
     
     


      ;
      ;


      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2)
 {
   while (__first1 != __last1 && !__predicate(*__first1, *__first2))
     ++__first1;
   return __first1;
 }


      _ForwardIterator2 __p1, __p;
      __p1 = __first2; ++__p1;
      _ForwardIterator1 __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;
    }
# 623 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val)
    {

     
     

     
      ;

      if (__count <= 0)
 return __first;
      else
 {
   __first = std::find(__first, __last, __val);
   while (__first != __last)
     {
       typename iterator_traits<_ForwardIterator>::difference_type
  __n = __count;
       _ForwardIterator __i = __first;
       ++__i;
       while (__i != __last && __n != 1 && *__i == __val)
  {
    ++__i;
    --__n;
  }
       if (__n == 1)
  return __first;
       else
  __first = std::find(__i, __last, __val);
     }
   return __last;
 }
    }
# 675 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
           typename _BinaryPredicate>
    _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {

     
     

      ;

      if (__count <= 0)
 return __first;
      else
 {
   while (__first != __last)
     {
       if (__binary_pred(*__first, __val))
  break;
       ++__first;
     }
   while (__first != __last)
     {
       typename iterator_traits<_ForwardIterator>::difference_type
  __n = __count;
       _ForwardIterator __i = __first;
       ++__i;
       while (__i != __last && __n != 1 && __binary_pred(*__i, __val))
  {
    ++__i;
    --__n;
  }
       if (__n == 1)
  return __first;
       else
  {
    while (__i != __last)
      {
        if (__binary_pred(*__i, __val))
   break;
        ++__i;
      }
    __first = __i;
  }
     }
   return __last;
 }
    }
# 737 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {

     

     

     


     


      ;

      for ( ; __first1 != __last1; ++__first1, ++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 775 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _UnaryOperation>
    _OutputIterator
    transform(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _UnaryOperation __unary_op)
    {

     
     


      ;

      for ( ; __first != __last; ++__first, ++__result)
 *__result = __unary_op(*__first);
      return __result;
    }
# 810 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _BinaryOperation>
    _OutputIterator
    transform(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _OutputIterator __result,
       _BinaryOperation __binary_op)
    {

     
     
     


      ;

      for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)
 *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 842 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
     const _Tp& __old_value, const _Tp& __new_value)
    {

     

     

     

      ;

      for ( ; __first != __last; ++__first)
 if (*__first == __old_value)
   *__first = __new_value;
    }
# 873 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
        _Predicate __pred, const _Tp& __new_value)
    {

     

     

     

      ;

      for ( ; __first != __last; ++__first)
 if (__pred(*__first))
   *__first = __new_value;
    }
# 906 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {

     
     

     

      ;

      for ( ; __first != __last; ++__first, ++__result)
 *__result = *__first == __old_value ? __new_value : *__first;
      return __result;
    }
# 939 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    _OutputIterator
    replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
    {

     
     

     

      ;

      for ( ; __first != __last; ++__first, ++__result)
 *__result = __pred(*__first) ? __new_value : *__first;
      return __result;
    }
# 970 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for ( ; __first != __last; ++__first)
 *__first = __gen();
    }
# 996 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {

     



      for ( ; __n > 0; --__n, ++__first)
 *__first = __gen();
      return __first;
    }
# 1023 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    _OutputIterator
    remove_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, const _Tp& __value)
    {

     
     

     

      ;

      for ( ; __first != __last; ++__first)
 if (!(*__first == __value))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 1059 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {

     
     

     

      ;

      for ( ; __first != __last; ++__first)
 if (!__pred(*__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 1098 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {

     

     

      ;

      __first = std::find(__first, __last, __value);
      _ForwardIterator __i = __first;
      return __first == __last ? __first
          : std::remove_copy(++__i, __last,
        __first, __value);
    }
# 1133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      __first = std::find_if(__first, __last, __pred);
      _ForwardIterator __i = __first;
      return __first == __last ? __first
          : std::remove_copy_if(++__i, __last,
           __first, __pred);
    }
# 1159 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    output_iterator_tag)
    {

      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!(__value == *__first))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }
# 1184 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    forward_iterator_tag)
    {

      *__result = *__first;
      while (++__first != __last)
 if (!(*__result == *__first))
   *++__result = *__first;
      return ++__result;
    }
# 1206 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    _BinaryPredicate __binary_pred,
    output_iterator_tag)
    {

     



      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!__binary_pred(__value, *__first))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }
# 1238 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    _BinaryPredicate __binary_pred,
    forward_iterator_tag)
    {

     



      *__result = *__first;
      while (++__first != __last)
 if (!__binary_pred(*__result, *__first)) *++__result = *__first;
      return ++__result;
    }
# 1270 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

     

      ;

      typedef typename iterator_traits<_OutputIterator>::iterator_category
 _IterType;

      if (__first == __last) return __result;
      return std::__unique_copy(__first, __last, __result, _IterType());
    }
# 1305 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {

     
     

      ;

      typedef typename iterator_traits<_OutputIterator>::iterator_category
 _IterType;

      if (__first == __last) return __result;
      return std::__unique_copy(__first, __last, __result,
    __binary_pred, _IterType());
    }
# 1339 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last)
    {

     

     

      ;


      __first = std::adjacent_find(__first, __last);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!(*__dest == *__first))
   *++__dest = *__first;
      return ++__dest;
    }
# 1378 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
           _BinaryPredicate __binary_pred)
    {

     

     


      ;


      __first = std::adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!__binary_pred(*__dest, *__first))
   *++__dest = *__first;
      return ++__dest;
    }
# 1412 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
     bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   std::iter_swap(__first++, __last);
    }
# 1431 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
     random_access_iterator_tag)
    {
      while (__first < __last)
 std::iter_swap(__first++, --__last);
    }
# 1451 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1477 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
        _OutputIterator __result)
    {

     

     

      ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }
# 1505 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _EuclideanRingElement>
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }






  template<typename _ForwardIterator>
    void
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
       forward_iterator_tag)
    {
      if ((__first == __middle) || (__last == __middle))
 return;

      _ForwardIterator __first2 = __middle;
      do
 {
   swap(*__first++, *__first2++);
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      __first2 = __middle;

      while (__first2 != __last)
 {
   swap(*__first++, *__first2++);
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
    }






  template<typename _BidirectionalIterator>
    void
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {

     


      if ((__first == __middle) || (__last == __middle))
 return;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 swap(*__first++, *--__last);

      if (__first == __middle)
 std::__reverse(__middle, __last, bidirectional_iterator_tag());
      else
 std::__reverse(__first, __middle, bidirectional_iterator_tag());
    }






  template<typename _RandomAccessIterator>
    void
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {

     


      if ((__first == __middle) || (__last == __middle))
 return;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      const _Distance __n = __last - __first;
      const _Distance __k = __middle - __first;
      const _Distance __l = __n - __k;

      if (__k == __l)
 {
   std::swap_ranges(__first, __middle, __middle);
   return;
 }

      const _Distance __d = __gcd(__n, __k);

      for (_Distance __i = 0; __i < __d; __i++)
 {
   const _ValueType __tmp = *__first;
   _RandomAccessIterator __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;
 }
    }
# 1677 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    inline void
    rotate(_ForwardIterator __first, _ForwardIterator __middle,
    _ForwardIterator __last)
    {

     

      ;
      ;

      typedef typename iterator_traits<_ForwardIterator>::iterator_category
 _IterType;
      std::__rotate(__first, __middle, __last, _IterType());
    }
# 1710 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
    _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
                _ForwardIterator __last, _OutputIterator __result)
    {

     
     

      ;
      ;

      return std::copy(__first, __middle, copy(__middle, __last, __result));
    }
# 1735 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

      ;

      if (__first != __last)
 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
   std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
    }
# 1762 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _RandomNumberGenerator& __rand)
    {

     

      ;

      if (__first == __last)
 return;
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 std::iter_swap(__i, __first + __rand((__i - __first) + 1));
    }







  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred,
  forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     swap(*__first, *__next);
     ++__first;
   }

      return __first;
    }






  template<typename _BidirectionalIterator, typename _Predicate>
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __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;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }
# 1856 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }







  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
    _ForwardIterator
    __inplace_stable_partition(_ForwardIterator __first,
          _ForwardIterator __last,
          _Predicate __pred, _Distance __len)
    {
      if (__len == 1)
 return __pred(*__first) ? __last : __first;
      _ForwardIterator __middle = __first;
      std::advance(__middle, __len / 2);
      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
         __middle,
         __pred,
         __len / 2);
      _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
              __pred,
              __len
              - __len / 2);
      std::rotate(__begin, __middle, __end);
      std::advance(__begin, std::distance(__middle, __end));
      return __begin;
    }






  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
    typename _Distance>
    _ForwardIterator
    __stable_partition_adaptive(_ForwardIterator __first,
    _ForwardIterator __last,
    _Predicate __pred, _Distance __len,
    _Pointer __buffer,
    _Distance __buffer_size)
    {
      if (__len <= __buffer_size)
 {
   _ForwardIterator __result1 = __first;
   _Pointer __result2 = __buffer;
   for ( ; __first != __last ; ++__first)
     if (__pred(*__first))
       {
  *__result1 = *__first;
  ++__result1;
       }
     else
       {
  *__result2 = *__first;
  ++__result2;
       }
   std::copy(__buffer, __result2, __result1);
   return __result1;
 }
      else
 {
   _ForwardIterator __middle = __first;
   std::advance(__middle, __len / 2);
   _ForwardIterator __begin =
     std::__stable_partition_adaptive(__first, __middle, __pred,
          __len / 2, __buffer,
          __buffer_size);
   _ForwardIterator __end =
     std::__stable_partition_adaptive(__middle, __last, __pred,
          __len - __len / 2,
          __buffer, __buffer_size);
   std::rotate(__begin, __middle, __end);
   std::advance(__begin, std::distance(__middle, __end));
   return __begin;
 }
    }
# 1967 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      if (__first == __last)
 return __first;
      else
 {
   typedef typename iterator_traits<_ForwardIterator>::value_type
     _ValueType;
   typedef typename iterator_traits<_ForwardIterator>::difference_type
     _DistanceType;

   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
        __last);
 if (__buf.size() > 0)
   return
     std::__stable_partition_adaptive(__first, __last, __pred,
       _DistanceType(__buf.requested_size()),
       __buf.begin(), __buf.size());
 else
   return
     std::__inplace_stable_partition(__first, __last, __pred,
      _DistanceType(__buf.requested_size()));
 }
    }






  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Tp __pivot)
    {
      while (true)
 {
   while (*__first < __pivot)
     ++__first;
   --__last;
   while (__pivot < *__last)
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }






  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _Tp __pivot, _Compare __comp)
    {
      while (true)
 {
   while (__comp(*__first, __pivot))
     ++__first;
   --__last;
   while (__comp(__pivot, *__last))
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }







  enum { _S_threshold = 16 };






  template<typename _RandomAccessIterator, typename _Tp>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
    {
      _RandomAccessIterator __next = __last;
      --__next;
      while (__val < *__next)
 {
   *__last = *__next;
   __last = __next;
   --__next;
 }
      *__last = __val;
    }






  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val,
         _Compare __comp)
    {
      _RandomAccessIterator __next = __last;
      --__next;
      while (__comp(__val, *__next))
 {
   *__last = *__next;
   __last = __next;
   --__next;
 }
      *__last = __val;
    }






  template<typename _RandomAccessIterator>
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last)
    {
      if (__first == __last)
 return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   typename iterator_traits<_RandomAccessIterator>::value_type
     __val = *__i;
   if (__val < *__first)
     {
       std::copy_backward(__first, __i, __i + 1);
       *__first = __val;
     }
   else
     std::__unguarded_linear_insert(__i, __val);
 }
    }






  template<typename _RandomAccessIterator, typename _Compare>
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last, _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   typename iterator_traits<_RandomAccessIterator>::value_type
     __val = *__i;
   if (__comp(__val, *__first))
     {
       std::copy_backward(__first, __i, __i + 1);
       *__first = __val;
     }
   else
     std::__unguarded_linear_insert(__i, __val, __comp);
 }
    }






  template<typename _RandomAccessIterator>
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i, _ValueType(*__i));
    }






  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i, _ValueType(*__i), __comp);
    }






  template<typename _RandomAccessIterator>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last)
    {
      if (__last - __first > _S_threshold)
 {
   std::__insertion_sort(__first, __first + _S_threshold);
   std::__unguarded_insertion_sort(__first + _S_threshold, __last);
 }
      else
 std::__insertion_sort(__first, __last);
    }






  template<typename _RandomAccessIterator, typename _Compare>
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > _S_threshold)
 {
   std::__insertion_sort(__first, __first + _S_threshold, __comp);
   std::__unguarded_insertion_sort(__first + _S_threshold, __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }






  template<typename _Size>
    inline _Size
    __lg(_Size __n)
    {
      _Size __k;
      for (__k = 0; __n != 1; __n >>= 1)
 ++__k;
      return __k;
    }
# 2256 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::make_heap(__first, __middle);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (*__i < *__first)
   std::__pop_heap(__first, __middle, __i, _ValueType(*__i));
      std::sort_heap(__first, __middle);
    }
# 2297 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      std::make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(*__i, *__first))
   std::__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
      std::sort_heap(__first, __middle, __comp);
    }
# 2339 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator>
    _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     
     

     
     
      ;
      ;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }
      std::make_heap(__result_first, __result_real_last);
      while (__first != __last)
 {
   if (*__first < *__result_first)
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first));
   ++__first;
 }
      std::sort_heap(__result_first, __result_real_last);
      return __result_real_last;
    }
# 2403 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
    _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last,
        _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _OutputValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     
     

     

     

      ;
      ;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while(__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }
      std::make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last)
 {
   if (__comp(*__first, *__result_first))
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first),
          __comp);
   ++__first;
 }
      std::sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }






  template<typename _RandomAccessIterator, typename _Size>
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > _S_threshold)
 {
   if (__depth_limit == 0)
     {
       std::partial_sort(__first, __last, __last);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last
          - 1))));
   std::__introsort_loop(__cut, __last, __depth_limit);
   __last = __cut;
 }
    }






  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > _S_threshold)
 {
   if (__depth_limit == 0)
     {
       std::partial_sort(__first, __last, __last, __comp);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last - 1),
        __comp)),
           __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }
# 2538 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last, __lg(__last - __first) * 2);
   std::__final_insertion_sort(__first, __last);
 }
    }
# 2572 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;

      if (__first != __last)
 {
   std::__introsort_loop(__first, __last, __lg(__last - __first) * 2,
    __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }
# 2605 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;






     
     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 2660 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(*__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 2707 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;



     
     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__val < *__middle)
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2759 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, *__middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }






  template<typename _BidirectionalIterator, typename _Distance>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (*__middle < *__first)
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22);
    }






  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
                           _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (__comp(*__middle, *__first))
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
       __comp);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
      __comp);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }






  template<typename _RandomAccessIterator>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle);
      std::__inplace_stable_sort(__middle, __last);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle);
    }






  template<typename _RandomAccessIterator, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 2957 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {

     
     
     

     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (*__first2 < *__first1)
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 3015 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {

     
     
     


     

     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(*__first2, *__first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result,
        _Distance __step_size)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::merge(__first, __first + __step_size,
    __first + __step_size, __first + __two_step,
    __result);
   __first += __two_step;
 }

      __step_size = std::min(_Distance(__last - __first), __step_size);
      std::merge(__first, __first + __step_size, __first + __step_size, __last,
   __result);
    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result, _Distance __step_size,
        _Compare __comp)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::merge(__first, __first + __step_size,
    __first + __step_size, __first + __two_step,
    __result,
    __comp);
   __first += __two_step;
 }
      __step_size = std::min(_Distance(__last - __first), __step_size);

      std::merge(__first, __first + __step_size,
   __first + __step_size, __last,
   __result,
   __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Distance>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last);
    }

  template<typename _RandomAccessIterator, typename _Distance, typename _Compare>
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  template<typename _RandomAccessIterator, typename _Pointer>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
                             _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }






  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (*__last2 < *__last1)
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__last2;
     }
 }
    }






  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(*__last2, *__last1))
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__last2;
     }
 }
    }






  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _Distance>
    _BidirectionalIterator1
    __rotate_adaptive(_BidirectionalIterator1 __first,
        _BidirectionalIterator1 __middle,
        _BidirectionalIterator1 __last,
        _Distance __len1, _Distance __len2,
        _BidirectionalIterator2 __buffer,
        _Distance __buffer_size)
    {
      _BidirectionalIterator2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size)
 {
   __buffer_end = std::copy(__middle, __last, __buffer);
   std::copy_backward(__first, __middle, __last);
   return std::copy(__buffer, __buffer_end, __first);
 }
      else if (__len1 <= __buffer_size)
 {
   __buffer_end = std::copy(__first, __middle, __buffer);
   std::copy(__middle, __last, __first);
   return std::copy_backward(__buffer, __buffer_end, __last);
 }
      else
 {
   std::rotate(__first, __middle, __last);
   std::advance(__first, std::distance(__middle, __last));
   return __first;
 }
    }






  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer>
    void
    __merge_adaptive(_BidirectionalIterator __first,
                     _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size)
    {
      if (__len1 <= __len2 && __len1 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
   std::merge(__buffer, __buffer_end, __middle, __last, __first);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_backward(__first, __middle, __buffer,
    __buffer_end, __last);
 }
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut = std::lower_bound(__middle, __last,
           *__first_cut);
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut = std::upper_bound(__first, __middle,
          *__second_cut);
       __len11 = std::distance(__first, __first_cut);
     }
   _BidirectionalIterator __new_middle =
     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
       __len1 - __len11, __len22, __buffer,
       __buffer_size);
   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    __len22, __buffer, __buffer_size);
   std::__merge_adaptive(__new_middle, __second_cut, __last,
    __len1 - __len11,
    __len2 - __len22, __buffer, __buffer_size);
 }
    }






  template<typename _BidirectionalIterator, typename _Distance, typename _Pointer,
    typename _Compare>
    void
    __merge_adaptive(_BidirectionalIterator __first,
                     _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size,
       _Compare __comp)
    {
      if (__len1 <= __len2 && __len1 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
   std::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_backward(__first, __middle, __buffer, __buffer_end,
    __last, __comp);
 }
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut = std::lower_bound(__middle, __last, *__first_cut,
           __comp);
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut = std::upper_bound(__first, __middle, *__second_cut,
          __comp);
       __len11 = std::distance(__first, __first_cut);
     }
   _BidirectionalIterator __new_middle =
     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
       __len1 - __len11, __len22, __buffer,
       __buffer_size);
   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
    __len22, __buffer, __buffer_size, __comp);
   std::__merge_adaptive(__new_middle, __second_cut, __last,
    __len1 - __len11,
    __len2 - __len22, __buffer,
    __buffer_size, __comp);
 }
    }
# 3435 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
          _DistanceType;


     

     
      ;
      ;

      if (__first == __middle || __middle == __last)
 return;

      _DistanceType __len1 = std::distance(__first, __middle);
      _DistanceType __len2 = std::distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
          __last);
      if (__buf.begin() == 0)
 std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
      else
 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
         __buf.begin(), _DistanceType(__buf.size()));
    }
# 3489 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
          _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
          _DistanceType;


     

     

      ;
      ;

      if (__first == __middle || __middle == __last)
 return;

      const _DistanceType __len1 = std::distance(__first, __middle);
      const _DistanceType __len2 = std::distance(__middle, __last);

      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
          __last);
      if (__buf.begin() == 0)
 std::__merge_without_buffer(__first, __middle, __last, __len1,
        __len2, __comp);
      else
 std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
         __buf.begin(), _DistanceType(__buf.size()),
         __comp);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle,
          __buffer, __buffer_size);
   std::__stable_sort_adaptive(__middle, __last,
          __buffer, __buffer_size);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer);
   std::__merge_sort_with_buffer(__middle, __last, __buffer);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
                           _Pointer __buffer, _Distance __buffer_size,
                           _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive(__middle, __last, __buffer,
          __buffer_size, __comp);
 }
      else
 {
   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
 }
      std::__merge_adaptive(__first, __middle, __last,
       _Distance(__middle - __first),
       _Distance(__last - __middle),
       __buffer, __buffer_size,
       __comp);
    }
# 3598 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     

     
      ;

      _Temporary_buffer<_RandomAccessIterator, _ValueType>
 buf(__first, __last);
      if (buf.begin() == 0)
 std::__inplace_stable_sort(__first, __last);
      else
 std::__stable_sort_adaptive(__first, __last, buf.begin(),
        _DistanceType(buf.size()));
    }
# 3639 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;


     

     


      ;

      _Temporary_buffer<_RandomAccessIterator, _ValueType> buf(__first, __last);
      if (buf.begin() == 0)
 std::__inplace_stable_sort(__first, __last, __comp);
      else
 std::__stable_sort_adaptive(__first, __last, buf.begin(),
        _DistanceType(buf.size()), __comp);
    }
# 3680 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    void
    nth_element(_RandomAccessIterator __first,
  _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      while (__last - __first > 3)
 {
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last
          - 1))));
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last);
    }
# 3731 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    nth_element(_RandomAccessIterator __first,
  _RandomAccessIterator __nth,
  _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      while (__last - __first > 3)
 {
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last - 1),
             __comp)), __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 3784 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;



     
     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__val < *__middle)
     __len = __half;
   else
     {
       __left = std::lower_bound(__first, __middle, __val);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 3846 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val,
  _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;


     
     

     

      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(*__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__comp(__val, *__middle))
     __len = __half;
   else
     {
       __left = std::lower_bound(__first, __middle, __val, __comp);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val, __comp);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 3904 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val)
    {


     
     

     
      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
      return __i != __last && !(__val < *__i);
    }
# 3936 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val, _Compare __comp)
    {

     
     

     

      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
      return __i != __last && !__comp(__val, *__i);
    }
# 3974 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first2 < *__first1)
   return false;
 else if(*__first1 < *__first2)
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 4020 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
    {

     
     
     


     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first2, *__first1))
   return false;
 else if(__comp(*__first1, *__first2))
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 4066 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {

     
     
     

     


     

      ;
      ;

      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 std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 4128 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {

     
     
     


     

     


      ;
      ;

      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 std::copy(__first2, __last2, std::copy(__first1, __last1,
          __result));
    }
# 4189 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {

     
     
     

     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   ++__first1;
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 4243 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {

     
     
     


     

     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   ++__first1;
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 4297 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {

     
     
     

     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 4355 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {

     
     
     


     

     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first1, __last1, __result);
    }
# 4409 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {

     
     
     

     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   {
     *__result = *__first1;
     ++__first1;
     ++__result;
   }
 else if (*__first2 < *__first1)
   {
     *__result = *__first2;
     ++__first2;
     ++__result;
   }
 else
   {
     ++__first1;
     ++__first2;
   }
      return std::copy(__first2, __last2, std::copy(__first1,
          __last1, __result));
    }
# 4470 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {

     
     
     


     

     


      ;
      ;

      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 std::copy(__first2, __last2, std::copy(__first1,
          __last1, __result));
    }
# 4523 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (*__result < *__first)
   __result = __first;
      return __result;
    }
# 4550 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;

      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(*__result, *__first)) __result = __first;
      return __result;
    }







  template<typename _ForwardIterator>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last)
    {

     
     

      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (*__first < *__result)
   __result = __first;
      return __result;
    }
# 4602 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {

     
     


      ;

      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(*__first, *__result))
   __result = __first;
      return __result;
    }
# 4637 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (*__i < *__ii)
     {
       _BidirectionalIterator __j = __last;
       while (!(*__i < *--__j))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 4693 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__i, *__ii))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(*__i, *--__j))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 4748 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {

     

     

      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (*__ii < *__i)
     {
       _BidirectionalIterator __j = __last;
       while (!(*--__j < *__i))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 4804 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last, _Compare __comp)
    {

     

     


      ;

      if (__first == __last)
 return false;
      _BidirectionalIterator __i = __first;
      ++__i;
      if (__i == __last)
 return false;
      __i = __last;
      --__i;

      for(;;)
 {
   _BidirectionalIterator __ii = __i;
   --__i;
   if (__comp(*__ii, *__i))
     {
       _BidirectionalIterator __j = __last;
       while (!__comp(*--__j, *__i))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 4863 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2)
    {

     
     
     


      ;
      ;

      for ( ; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (*__first1 == *__iter)
     return __first1;
      return __last1;
    }
# 4899 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2,
    _BinaryPredicate __comp)
    {

     
     
     


     


      ;
      ;

      for ( ; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (__comp(*__first1, *__iter))
     return __first1;
      return __last1;
    }
# 4932 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2, __last2);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;
      else
 {
   _ForwardIterator1 __result = __last1;
   while (1)
     {
       _ForwardIterator1 __new_result
  = std::search(__first1, __last1, __first2, __last2, __comp);
       if (__new_result == __last1)
  return __result;
       else
  {
    __result = __new_result;
    __first1 = __new_result;
    ++__first1;
  }
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
         _RevIterator2(__last2), __rlast2);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }

  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {

     

     


      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
         _RevIterator2(__last2), __rlast2,
         __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 5082 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2));
    }
# 5127 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __comp)
    {

     
     
     


      ;
      ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __comp);
    }

}
# 70 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/algorithm" 2 3
# 57 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.tcc" 1 3
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.tcc" 3
       
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.tcc" 3

namespace std
{
  template<typename _Type>
    inline bool
    __is_null_pointer(_Type* __ptr)
    { return __ptr == 0; }

  template<typename _Type>
    inline bool
    __is_null_pointer(_Type)
    { return false; }

  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_base))/sizeof(_CharT)) - 1) / 4;

  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>::npos;



  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
      sizeof(size_type)];





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     input_iterator_tag)
      {
 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();

 _CharT __buf[128];
 size_type __len = 0;
 while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
   {
     __buf[__len++] = *__beg;
     ++__beg;
   }
 _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
 traits_type::copy(__r->_M_refdata(), __buf, __len);
 try
   {
     while (__beg != __end)
       {
  if (__len == __r->_M_capacity)
    {

      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
      traits_type::copy(__another->_M_refdata(),
          __r->_M_refdata(), __len);
      __r->_M_destroy(__a);
      __r = __another;
    }
  __r->_M_refdata()[__len++] = *__beg;
  ++__beg;
       }
   }
 catch(...)
   {
     __r->_M_destroy(__a);
     throw;
   }
 __r->_M_length = __len;
 __r->_M_refdata()[__len] = _Rep::_S_terminal;
 return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template <typename _InIterator>
      _CharT*
      basic_string<_CharT, _Traits, _Alloc>::
      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
     forward_iterator_tag)
      {
 if (__beg == __end && __a == _Alloc())
   return _S_empty_rep()._M_refdata();


 if (__builtin_expect(__is_null_pointer(__beg), 0))
   __throw_logic_error(("basic_string::_S_construct NULL not valid"));

 const size_type __dnew = static_cast<size_type>(std::distance(__beg,
              __end));

 _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __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_refdata();


      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
      if (__n)
 traits_type::assign(__r->_M_refdata(), __n, __c);

      __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()),
    __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_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, _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_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, __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 ? __s + traits_type::length(__s) :
          __s + npos, __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 _InputIterator>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIterator __beg, _InputIterator __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())
 {

   const 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>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     assign(const _CharT* __s, size_type __n)
     {
       ;
       if (__n > this->max_size())
  __throw_length_error(("basic_string::assign"));
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
    || less<const _CharT*>()(_M_data() + this->size(), __s))
  return _M_replace_safe(size_type(0), this->size(), __s, __n);
       else
  {

    const size_type __pos = __s - _M_data();
    if (__pos >= __n)
      traits_type::copy(_M_data(), __s, __n);
    else if (__pos)
      traits_type::move(_M_data(), __s, __n);
    _M_rep()->_M_set_sharable();
    _M_rep()->_M_length = __n;
    _M_data()[__n] = _Rep::_S_terminal;
    return *this;
  }
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     insert(size_type __pos, const _CharT* __s, size_type __n)
     {
       ;
       _M_check(__pos, "basic_string::insert");
       if (this->max_size() - this->size() < __n)
  __throw_length_error(("basic_string::insert"));
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
           || less<const _CharT*>()(_M_data() + this->size(), __s))
         return _M_replace_safe(__pos, size_type(0), __s, __n);
       else
         {



           const size_type __off = __s - _M_data();
           _M_mutate(__pos, 0, __n);
           __s = _M_data() + __off;
           _CharT* __p = _M_data() + __pos;
           if (__s + __n <= __p)
             traits_type::copy(__p, __s, __n);
           else if (__s >= __p)
             traits_type::copy(__p, __s + __n, __n);
           else
             {
        const size_type __nleft = __p - __s;
               traits_type::copy(__p, __s, __nleft);
               traits_type::copy(__p + __nleft, __p + __n, __n - __nleft);
             }
           return *this;
         }
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     replace(size_type __pos, size_type __n1, const _CharT* __s,
      size_type __n2)
     {
       ;
       _M_check(__pos, "basic_string::replace");
       __n1 = _M_limit(__pos, __n1);
       if (this->max_size() - (this->size() - __n1) < __n2)
         __throw_length_error(("basic_string::replace"));
       bool __left;
       if (_M_rep()->_M_is_shared() || less<const _CharT*>()(__s, _M_data())
    || less<const _CharT*>()(_M_data() + this->size(), __s))
         return _M_replace_safe(__pos, __n1, __s, __n2);
       else if ((__left = __s + __n2 <= _M_data() + __pos)
  || _M_data() + __pos + __n1 <= __s)
  {

    const size_type __off = __s - _M_data();
    _M_mutate(__pos, __n1, __n2);
    if (__left)
      traits_type::copy(_M_data() + __pos,
          _M_data() + __off, __n2);
    else
      traits_type::copy(_M_data() + __pos,
          _M_data() + __off + __n2 - __n1, __n2);
    return *this;
  }
       else
  {

    const basic_string __tmp(__s, __n2);
    return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
  }
     }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _M_destroy(const _Alloc& __a) throw ()
    {
      if (this == &_S_empty_rep())
        return;
      const size_type __size = sizeof(_Rep_base) +
                        (this->_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() == &_S_empty_rep())
        return;
      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)
    {
      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;
      const size_type __how_much = __old_size - __pos - __len1;

      if (_M_rep() == &_S_empty_rep()
   || _M_rep()->_M_is_shared() || __new_size > capacity())
 {

   const allocator_type __a = get_allocator();
   _Rep* __r = _Rep::_S_create(__new_size, capacity(), __a);

   if (__pos)
     traits_type::copy(__r->_M_refdata(), _M_data(), __pos);
   if (__how_much)
     traits_type::copy(__r->_M_refdata() + __pos + __len2,
         _M_data() + __pos + __len1, __how_much);

   _M_rep()->_M_dispose(__a);
   _M_data(__r->_M_refdata());
 }
      else if (__how_much && __len1 != __len2)
 {

   traits_type::move(_M_data() + __pos + __len2,
       _M_data() + __pos + __len1, __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())
        {
   if (__res > this->max_size())
     __throw_length_error(("basic_string::reserve"));

   if (__res < this->size())
     __res = this->size();
   const 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
 {
   const basic_string __tmp1(_M_ibegin(), _M_iend(),
        __s.get_allocator());
   const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
        this->get_allocator());
   *this = __tmp2;
   __s = __tmp1;
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
    basic_string<_CharT, _Traits, _Alloc>::_Rep::
    _S_create(size_type __capacity, size_type __old_capacity,
       const _Alloc& __alloc)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;


      if (__capacity > _S_max_size)
 __throw_length_error(("basic_string::_S_create"));
# 494 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.tcc" 3
      const size_type __pagesize = 4096;
      const size_type __subpagesize = 128;
      const size_type __malloc_header_size = 4 * sizeof (void*);
# 506 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_string.tcc" 3
      const size_type __page_capacity = ((__pagesize - __malloc_header_size
       - sizeof(_Rep) - sizeof(_CharT))
      / sizeof(_CharT));

      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity
   && __capacity > __page_capacity)
 __capacity = 2 * __old_capacity;




      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);

      const size_type __adj_size = __size + __malloc_header_size;
      if (__adj_size > __pagesize)
 {
   const size_type __extra = __pagesize - __adj_size % __pagesize;
   __capacity += __extra / sizeof(_CharT);

   if (__capacity > _S_max_size)
     __capacity = _S_max_size;
   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
 }
      else if (__size > __subpagesize)
 {
   const size_type __extra = __subpagesize - __adj_size % __subpagesize;
   __capacity += __extra / sizeof(_CharT);
   __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)
    {

      const size_type __requested_cap = this->_M_length + __res;
      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
      __alloc);
      if (this->_M_length)
 traits_type::copy(__r->_M_refdata(), _M_refdata(),
     this->_M_length);

      __r->_M_length = this->_M_length;
      __r->_M_refdata()[this->_M_length] = _Rep::_S_terminal;
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    void
    basic_string<_CharT, _Traits, _Alloc>::resize(size_type __n, _CharT __c)
    {
      if (__n > max_size())
 __throw_length_error(("basic_string::resize"));
      const 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 _InputIterator>
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
     _InputIterator __k2, __false_type)
      {
 const basic_string __s(__k1, __k2);
 const size_type __n1 = __i2 - __i1;
 if (this->max_size() - (this->size() - __n1) < __s.size())
   __throw_length_error(("basic_string::_M_replace_dispatch"));
 return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
          __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str)
    {



      const size_type __size = __str.size();
      const size_type __len = __size + this->size();
      if (__len > this->capacity())
 this->reserve(__len);
      return _M_replace_safe(this->size(), size_type(0), __str._M_data(),
        __str.size());
    }

  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)
    {



      __str._M_check(__pos, "basic_string::append");
      __n = __str._M_limit(__pos, __n);
      const size_type __len = __n + this->size();
      if (__len > this->capacity())
 this->reserve(__len);
      return _M_replace_safe(this->size(), size_type(0), __str._M_data()
        + __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)
    {
      ;
      const size_type __len = __n + this->size();
      if (__len > this->capacity())
 this->reserve(__len);
      return _M_replace_safe(this->size(), size_type(0), __s, __n);
    }

  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;
      const __size_type __len = _Traits::length(__lhs);
      __string_type __str;
      __str.reserve(__len + __rhs.size());
      __str.append(__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;
      const __size_type __len = __rhs.size();
      __str.reserve(__len + 1);
      __str.append(__size_type(1), __lhs);
      __str.append(__rhs);
      return __str;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
      ;
      if (__n)
 traits_type::copy(__s, _M_data() + __pos, __n);

      return __n;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      const _CharT* __data = _M_data();
      for (; __pos + __n <= __size; ++__pos)
 if (traits_type::compare(__data + __pos, __s, __n) == 0)
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const
    {
      const size_type __size = this->size();
      size_type __ret = npos;
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const 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>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    {
      ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__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>
    typename 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)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename 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>
    typename 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>
    typename 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
    {
      ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    typename 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)
 {
   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>
    typename 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
    {
      _M_check(__pos, "basic_string::compare");
      __n = _M_limit(__pos, __n);
      const size_type __osize = __str.size();
      const size_type __len = std::min(__n, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
      if (!__r)
 __r = __n - __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
    {
      _M_check(__pos1, "basic_string::compare");
      __str._M_check(__pos2, "basic_string::compare");
      __n1 = _M_limit(__pos1, __n1);
      __n2 = __str._M_limit(__pos2, __n2);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos1,
         __str.data() + __pos2, __len);
      if (!__r)
 __r = __n1 - __n2;
      return __r;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    int
    basic_string<_CharT, _Traits, _Alloc>::
    compare(const _CharT* __s) const
    {
      ;
      const size_type __size = this->size();
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__size, __osize);
      int __r = traits_type::compare(_M_data(), __s, __len);
      if (!__r)
 __r = __size - __osize;
      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) const
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __osize = traits_type::length(__s);
      const size_type __len = std::min(__n1, __osize);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = __n1 - __osize;
      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
    {
      ;
      _M_check(__pos, "basic_string::compare");
      __n1 = _M_limit(__pos, __n1);
      const size_type __len = std::min(__n1, __n2);
      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
      if (!__r)
 __r = __n1 - __n2;
      return __r;
    }





  extern template class basic_string<char>;
  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);


  extern template class basic_string<wchar_t>;
  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);


}
# 58 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/string" 2 3
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 2 3



namespace std
{
# 67 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
  class locale
  {
  public:


    typedef int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;
# 105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (ctype | numeric | collate |
        time | monetary | messages);
# 124 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    locale() throw();
# 133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 143 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 158 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 171 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 183 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 197 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 212 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    string
    name() const;
# 231 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw ();







    inline bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }
# 259 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 275 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    static locale
    global(const locale&);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 310 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    static const size_t _S_categories_size = 6 + 6;


    static __gthread_once_t _S_once;


    explicit
    locale(_Impl*) throw();

    static void
    _S_initialize();

    static void
    _S_initialize_once();

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);
  };
# 343 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
  class locale::facet
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    mutable _Atomic_word _M_refcount;


    static __c_locale _S_c_locale;


    static const char _S_c_name[2];


    static __gthread_once_t _S_once;


    static void
    _S_initialize_once();

  protected:
# 374 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
    explicit
    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
    { }


    virtual
    ~facet();

    static void
    _S_create_c_locale(__c_locale& __cloc, const char* __s,
         __c_locale __old = 0);

    static __c_locale
    _S_clone_c_locale(__c_locale& __cloc);

    static void
    _S_destroy_c_locale(__c_locale& __cloc);



    static __c_locale
    _S_get_c_locale();

    static const char*
    _S_get_c_name();

  private:
    inline void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add(&_M_refcount, 1); }

    inline void
    _M_remove_reference() const throw()
    {
      if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
 {
   try
     { delete this; }
   catch (...)
     { }
 }
    }

    facet(const facet&);

    facet&
    operator=(const facet&);
  };
# 434 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_classes.h" 3
  class locale::id
  {
  private:
    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 ();




    mutable size_t _M_index;


    static _Atomic_word _S_refcount;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }

    size_t
    _M_id() const;
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Cache>
      friend struct __use_cache;

  private:

    _Atomic_word _M_refcount;
    const facet** _M_facets;
    size_t _M_facets_size;
    const facet** _M_caches;
    char** _M_names;
    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()
    { __gnu_cxx::__atomic_add(&_M_refcount, 1); }

    inline void
    _M_remove_reference() throw()
    {
      if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
 {
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    inline bool
    _M_check_same_name()
    {
      bool __ret = true;
      for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
 __ret = std::strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    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*, const facet*);

    template<typename _Facet>
      inline void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    void
    _M_install_cache(const facet* __cache, size_t __index) throw()
    {
      __cache->_M_add_reference();
      _M_caches[__index] = __cache;
    }
  };

  template<typename _Facet>
    locale::locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      char* _M_tmp_names[_S_categories_size];
      size_t __i = 0;
      try
 {
   for (; __i < _S_categories_size; ++__i)
     {
       _M_tmp_names[__i] = new char[2];
       std::strcpy(_M_tmp_names[__i], "*");
     }
   _M_impl->_M_install_facet(&_Facet::id, __f);
 }
      catch(...)
 {
   _M_impl->_M_remove_reference();
   for (size_t __j = 0; __j < __i; ++__j)
     delete [] _M_tmp_names[__j];
   throw;
 }

      for (size_t __k = 0; __k < _S_categories_size; ++__k)
 {
   delete [] _M_impl->_M_names[__k];
   _M_impl->_M_names[__k] = _M_tmp_names[__k];
 }
    }
}
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 2 3

namespace std
{




  enum _Ios_Fmtflags { _S_ios_fmtflags_end = 1L << 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 { _S_ios_openmode_end = 1L << 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 { _S_ios_iostate_end = 1L << 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 { _S_ios_seekdir_end = 1L << 16 };
# 158 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
  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:
      string _M_msg;
    };
# 210 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    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);
# 285 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    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);
# 316 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    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);
# 349 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    typedef _Ios_Seekdir seekdir;


    static const seekdir beg = seekdir(0);


    static const seekdir cur = seekdir(1);


    static const seekdir end = seekdir(2);
# 377 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 394 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    typedef void (*event_callback) (event, ios_base&, int);
# 406 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    void
    register_callback(event_callback __fn, int __index);

  protected:






    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;




    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _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() { __gnu_cxx::__atomic_add(&_M_refcount, 1); }


      int
      _M_remove_reference()
      { return __gnu_cxx::__exchange_and_add(&_M_refcount, -1); }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void);


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
      _Words() : _M_pword(0), _M_iword(0) { }
    };


    _Words _M_word_zero;



    static const int _S_local_word_size = 8;
    _Words _M_local_word[_S_local_word_size];


    int _M_word_size;
    _Words* _M_word;

    _Words&
    _M_grow_words(int __index, bool __iword);


    locale _M_ios_locale;

    void
    _M_init();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();

    private:
      static _Atomic_word _S_refcount;
      static bool _S_synced_with_stdio;
    };






    inline fmtflags
    flags() const { return _M_flags; }
# 516 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 532 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 549 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    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; }
# 576 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    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;
    }
# 625 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 637 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc);
# 648 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline locale
    getloc() const { return _M_ios_locale; }
# 658 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline const locale&
    _M_getloc() const { return _M_ios_locale; }
# 676 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 692 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 713 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    inline void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 730 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ios_base.h" 3
    virtual ~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;
  }
}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3






namespace std
{





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout);
# 122 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
  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;
# 145 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      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
      __copy_streambufs<>(__streambuf_type* __sbin,
     __streambuf_type* __sbout);

    protected:
# 169 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      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;






      locale _M_buf_locale;

  public:

      virtual
      ~basic_streambuf()
      { }
# 197 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      locale
      pubimbue(const locale &__loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 214 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 227 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      __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(); }
# 254 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 268 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      snextc()
      {
 int_type __ret = traits_type::eof();
 if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
             __ret), true))
   __ret = this->sgetc();
 return __ret;
      }
# 286 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      sbumpc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 else
   __ret = this->uflow();
 return __ret;
      }
# 308 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      sgetc()
      {
 int_type __ret;
 if (__builtin_expect(this->gptr() < this->egptr(), true))
   __ret = traits_type::to_int_type(*this->gptr());
 else
   __ret = this->underflow();
 return __ret;
      }
# 327 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 341 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      sputbackc(char_type __c)
      {
 int_type __ret;
 const bool __testpos = this->eback() < this->gptr();
 if (__builtin_expect(!__testpos ||
        !traits_type::eq(__c, this->gptr()[-1]), false))
   __ret = this->pbackfail(traits_type::to_int_type(__c));
 else
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 return __ret;
      }
# 366 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      sungetc()
      {
 int_type __ret;
 if (__builtin_expect(this->eback() < this->gptr(), true))
   {
     this->gbump(-1);
     __ret = traits_type::to_int_type(*this->gptr());
   }
 else
   __ret = this->pbackfail();
 return __ret;
      }
# 393 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      int_type
      sputc(char_type __c)
      {
 int_type __ret;
 if (__builtin_expect(this->pptr() < this->epptr(), true))
   {
     *this->pptr() = __c;
     this->pbump(1);
     __ret = traits_type::to_int_type(__c);
   }
 else
   __ret = this->overflow(traits_type::to_int_type(__c));
 return __ret;
      }
# 419 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 433 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      basic_streambuf()
      : _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_buf_locale(locale())
      { }
# 451 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }
# 467 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 478 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
 _M_in_beg = __gbeg;
 _M_in_cur = __gnext;
 _M_in_end = __gend;
      }
# 498 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }
# 514 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 524 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 545 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual void
      imbue(const locale&)
      { }
# 560 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 571 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 583 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 596 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual int
      sync() { return 0; }
# 618 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 634 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 656 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 669 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual int_type
      uflow()
      {
 int_type __ret = traits_type::eof();
 const bool __testeof = traits_type::eq_int_type(this->underflow(),
       __ret);
 if (!__testeof)
   {
     __ret = traits_type::to_int_type(*this->gptr());
     this->gbump(1);
   }
 return __ret;
      }
# 693 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 711 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 736 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 765 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 3
    private:


      basic_streambuf(const __streambuf_type& __sb)
      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
      _M_buf_locale(__sb._M_buf_locale)
      { }

      __streambuf_type&
      operator=(const __streambuf_type&) { return *this; };
    };
}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf.tcc" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf.tcc" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf.tcc" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const size_t __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const size_t __remaining = __n - __ret;
       const size_t __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->gbump(__len);
     }

   if (__ret < __n)
     {
       const int_type __c = this->uflow();
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    traits_type::assign(*__s++, traits_type::to_char_type(__c));
    ++__ret;
  }
       else
  break;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const size_t __buf_len = this->epptr() - this->pptr();
   if (__buf_len)
     {
       const size_t __remaining = __n - __ret;
       const size_t __len = std::min(__buf_len, __remaining);
       traits_type::copy(this->pptr(), __s, __len);
       __ret += __len;
       __s += __len;
       this->pbump(__len);
     }

   if (__ret < __n)
     {
       int_type __c = this->overflow(traits_type::to_int_type(*__s));
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    ++__ret;
    ++__s;
  }
       else
  break;
     }
 }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      streamsize __ret = 0;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   const size_t __n = __sbin->egptr() - __sbin->gptr();
   if (__n > 1)
     {
       const size_t __wrote = __sbout->sputn(__sbin->gptr(), __n);
       __sbin->gbump(__wrote);
       __ret += __wrote;
       if (__wrote < __n)
  break;
       __c = __sbin->underflow();
     }
   else
     {
       __c = __sbout->sputc(_Traits::to_char_type(__c));
       if (_Traits::eq_int_type(__c, _Traits::eof()))
  break;
       ++__ret;
       __c = __sbin->snextc();
     }
 }
      return __ret;
    }





  extern template class basic_streambuf<char>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*, basic_streambuf<char>*);


  extern template class basic_streambuf<wchar_t>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*);


}
# 782 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/streambuf" 2 3
# 51 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 1 3
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
       
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf_iterator.h" 1 3
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf_iterator.h" 3
       
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/streambuf_iterator.h" 3






namespace std
{


  template<typename _CharT, typename _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;


    private:







      mutable streambuf_type* _M_sbuf;
      int_type _M_c;

    public:

      istreambuf_iterator() throw()
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      istreambuf_iterator(istream_type& __s) throw()
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }




      char_type
      operator*() const
      {







 return traits_type::to_char_type(_M_get());
      }


      istreambuf_iterator&
      operator++()
      {
 ;


 const int_type __eof = traits_type::eof();
 if (_M_sbuf && traits_type::eq_int_type(_M_sbuf->sbumpc(), __eof))
   _M_sbuf = 0;
 else
   _M_c = __eof;
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {
 ;



 const int_type __eof = traits_type::eof();
 istreambuf_iterator __old = *this;
 if (_M_sbuf
     && traits_type::eq_int_type((__old._M_c = _M_sbuf->sbumpc()),
     __eof))
   _M_sbuf = 0;
 else
   _M_c = __eof;
 return __old;
      }





      bool
      equal(const istreambuf_iterator& __b) const
      {
 const bool __thiseof = _M_at_eof();
 const bool __beof = __b._M_at_eof();
 return (__thiseof && __beof || (!__thiseof && !__beof));
      }

    private:
      int_type
      _M_get() const
      {
 const int_type __eof = traits_type::eof();
 int_type __ret = __eof;
 if (_M_sbuf)
   {
     if (!traits_type::eq_int_type(_M_c, __eof))
       __ret = _M_c;
     else if (traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
           __eof))
       _M_sbuf = 0;
   }
 return __ret;
      }

      bool
      _M_at_eof() const
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(_M_get(), __eof);
      }
    };

  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); }


  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:



      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:

      ostreambuf_iterator(ostream_type& __s) throw ()
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) throw ()
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


      ostreambuf_iterator&
      operator*()
      { return *this; }


      ostreambuf_iterator&
      operator++(int)
      { return *this; }


      ostreambuf_iterator&
      operator++()
      { return *this; }


      bool
      failed() const throw()
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };
}
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 2 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwctype" 1 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwctype" 3
       
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwctype" 3




# 1 "/usr/include/wctype.h" 1 3 4
# 35 "/usr/include/wctype.h" 3 4
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/stddef.h" 1 3 4
# 36 "/usr/include/wctype.h" 2 3 4
# 45 "/usr/include/wctype.h" 3 4



# 64 "/usr/include/wctype.h" 3 4



typedef unsigned long int wctype_t;

# 86 "/usr/include/wctype.h" 3 4
enum
{
  __ISwupper = 0,
  __ISwlower = 1,
  __ISwalpha = 2,
  __ISwdigit = 3,
  __ISwxdigit = 4,
  __ISwspace = 5,
  __ISwprint = 6,
  __ISwgraph = 7,
  __ISwblank = 8,
  __ISwcntrl = 9,
  __ISwpunct = 10,
  __ISwalnum = 11,

  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};



extern "C" {








extern int iswalnum (wint_t __wc) throw ();





extern int iswalpha (wint_t __wc) throw ();


extern int iswcntrl (wint_t __wc) throw ();



extern int iswdigit (wint_t __wc) throw ();



extern int iswgraph (wint_t __wc) throw ();




extern int iswlower (wint_t __wc) throw ();


extern int iswprint (wint_t __wc) throw ();




extern int iswpunct (wint_t __wc) throw ();




extern int iswspace (wint_t __wc) throw ();




extern int iswupper (wint_t __wc) throw ();




extern int iswxdigit (wint_t __wc) throw ();





extern int iswblank (wint_t __wc) throw ();
# 186 "/usr/include/wctype.h" 3 4
extern wctype_t wctype (__const char *__property) throw ();



extern int iswctype (wint_t __wc, wctype_t __desc) throw ();










typedef __const __int32_t *wctrans_t;







extern wint_t towlower (wint_t __wc) throw ();


extern wint_t towupper (wint_t __wc) throw ();


}
# 228 "/usr/include/wctype.h" 3 4
extern "C" {




extern wctrans_t wctrans (__const char *__property) throw ();


extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();








extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();





extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();


extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();



extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();



extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();


extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();




extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();



extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
     throw ();



extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
     throw ();







extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();


extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();



extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale)
     throw ();


extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
      __locale_t __locale) throw ();



}
# 53 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwctype" 2 3
# 79 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/cwctype" 3
namespace std
{
  using ::wint_t;

  using ::wctype_t;
  using ::wctrans_t;

  using ::iswalnum;
  using ::iswalpha;

  using ::iswblank;

  using ::iswcntrl;
  using ::iswdigit;
  using ::iswgraph;
  using ::iswlower;
  using ::iswprint;
  using ::iswprint;
  using ::iswpunct;
  using ::iswspace;
  using ::iswupper;
  using ::iswxdigit;
  using ::iswctype;
  using ::towlower;
  using ::towupper;
  using ::towctrans;
  using ::wctrans;
  using ::wctype;
}
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 2 3




namespace std
{
# 63 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _Tv>
    void
    __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
     const __c_locale& __cloc);


  template<>
    void
    __convert_to_v(const char*, float&, ios_base::iostate&,
     const __c_locale&);

  template<>
    void
    __convert_to_v(const char*, double&, ios_base::iostate&,
     const __c_locale&);

  template<>
    void
    __convert_to_v(const char*, long double&, ios_base::iostate&,
     const __c_locale&);



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      const _CharT* __olds, const streamsize __newlen,
      const streamsize __oldlen, const bool __num);
    };






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
 *__s = __ws[__j];
      return __s;
    }




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/ctype_base.h" 1 3
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/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 = _ISalpha | _ISdigit | _ISpunct;
    static const mask cntrl = _IScntrl;
    static const mask punct = _ISpunct;
    static const mask alnum = _ISalpha | _ISdigit;
  };
# 133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 2 3
# 144 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 162 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 179 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 195 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 211 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 225 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 240 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 254 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 269 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 286 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 305 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 324 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 346 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
       char __dfault, char *__to) const
      { return this->do_narrow(__lo, __hi, __dfault, __to); }

    protected:
      explicit
      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }

      virtual
      ~__ctype_abstract_base() { }
# 371 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 390 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 409 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 428 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 446 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const = 0;
# 463 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 479 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const = 0;
# 496 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 515 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const = 0;
# 536 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi,
        char_type* __dest) const = 0;
# 558 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const = 0;
# 582 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const = 0;
    };
# 605 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename __ctype_abstract_base<_CharT>::mask mask;


      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   protected:
      virtual
      ~ctype();

      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 __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;
# 674 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<>
    class ctype<char> : public locale::facet, public ctype_base
    {
    public:


      typedef char char_type;

    protected:

      __c_locale _M_c_locale_ctype;
      bool _M_del;
      __to_type _M_toupper;
      __to_type _M_tolower;
      const mask* _M_table;
      mutable char _M_widen_ok;
      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow_ok;


    public:

      static locale::id id;

      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 711 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 724 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 737 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 752 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 766 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 780 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 795 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 812 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 828 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 845 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 865 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      {
 if (_M_widen_ok) return _M_widen[static_cast<unsigned char>(__c)];
 this->_M_widen_init();
 return this->do_widen(__c);
      }
# 891 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok) _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 921 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      {
 if (_M_narrow[static_cast<unsigned char>(__c)])
   return _M_narrow[static_cast<unsigned char>(__c)];
 const char __t = do_narrow(__c, __dfault);
 if (__t != __dfault) _M_narrow[static_cast<unsigned char>(__c)] = __t;
 return __t;
      }
# 953 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
      char __dfault, char *__to) const
      {
 if (__builtin_expect(_M_narrow_ok == 1,true))
   {
     memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }

    protected:


      const mask*
      table() const throw()
      { return _M_table; }


      static const mask*
      classic_table() throw();







      virtual
      ~ctype();
# 1000 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1017 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1033 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1050 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1070 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1093 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
      {
 memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }
# 1119 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char) const
      { return __c; }
# 1145 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char, char* __dest) const
      {
 memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }

    private:

      void _M_widen_init() const
      {
 char __tmp[sizeof(_M_widen)];
 for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
   __tmp[__i] = __i;
 do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);

 _M_widen_ok = 1;

 for (size_t __j = 0; __j < sizeof(_M_widen); ++__j)
   if (__tmp[__j] != _M_widen[__j])
     {
       _M_widen_ok = 2;
       break;
     }
      }




      void _M_narrow_init() const
      {
 char __tmp[sizeof(_M_narrow)];
 for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
   __tmp[__i] = __i;
 do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);



 bool __consecutive = true;
 for (size_t __j = 0; __j < sizeof(_M_narrow); ++__j)
   if (!_M_narrow[__j])
     {
       char __c;
       do_narrow(__tmp + __j, __tmp + __j + 1, 1, &__c);
       if (__c == 1)
  {
    __consecutive = false;
    break;
  }
     }
 _M_narrow_ok = __consecutive ? 1 : 2;
      }
    };

  template<>
    const ctype<char>&
    use_facet<ctype<char> >(const locale& __loc);
# 1216 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<>
    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    {
    public:


      typedef wchar_t char_type;
      typedef wctype_t __wmask_type;

    protected:
      __c_locale _M_c_locale_ctype;


      bool _M_narrow_ok;
      char _M_narrow[128];
      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


      mask _M_bit[16];
      __wmask_type _M_wmask[16];

    public:


      static locale::id id;
# 1249 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1260 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    protected:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const;


      virtual
      ~ctype();
# 1284 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1303 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1321 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1339 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1356 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1373 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1389 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1406 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1426 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const;
# 1448 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
# 1471 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const;
# 1497 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const;


      void
      _M_initialize_ctype();
    };

  template<>
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale& __loc);



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/ctype_inline.h" 1 3
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/ctype_inline.h" 3
  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[static_cast<unsigned char>(__c)] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && !(_M_table[static_cast<unsigned char>(*__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[static_cast<unsigned char>(*__low)] & __m) != 0)
      ++__low;
    return __low;
  }
# 1513 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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* __s, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname() { };
    };


  template<>
    ctype_byname<char>::ctype_byname(const char*, size_t refs);

  template<>
    ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 1 3
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
       
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3



  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 73 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
  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;
# 120 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
      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);
      }
# 159 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
      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); }
# 199 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
      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(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() { }
# 240 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 3
      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(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;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }

      explicit
      codecvt(__c_locale __cloc, 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(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  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;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, 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(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };



  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, 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(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }

    protected:
      virtual
      ~codecvt_byname() { }
    };




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/codecvt_specializations.h" 1 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/codecvt_specializations.h" 3
  class __enc_traits
  {
  public:



    typedef iconv_t __desc_type;

  protected:


    static const int _S_max_size = 32;

    char _M_int_enc[_S_max_size];

    char _M_ext_enc[_S_max_size];


    __desc_type _M_in_desc;

    __desc_type _M_out_desc;


    int _M_ext_bom;


    int _M_int_bom;

  public:
    explicit __enc_traits()
    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(0), _M_int_bom(0)
    {
      memset(_M_int_enc, 0, _S_max_size);
      memset(_M_ext_enc, 0, _S_max_size);
    }

    explicit __enc_traits(const char* __int, const char* __ext,
     int __ibom = 0, int __ebom = 0)
    : _M_in_desc(0), _M_out_desc(0), _M_ext_bom(__ebom), _M_int_bom(__ibom)
    {
      strncpy(_M_int_enc, __int, _S_max_size);
      strncpy(_M_ext_enc, __ext, _S_max_size);
      _M_init();
    }
# 99 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/codecvt_specializations.h" 3
    __enc_traits(const __enc_traits& __obj): _M_in_desc(0), _M_out_desc(0)
    {
      strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
      strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
      _M_ext_bom = __obj._M_ext_bom;
      _M_int_bom = __obj._M_int_bom;
      _M_destroy();
      _M_init();
    }


    __enc_traits&
    operator=(const __enc_traits& __obj)
    {
      strncpy(_M_int_enc, __obj._M_int_enc, _S_max_size);
      strncpy(_M_ext_enc, __obj._M_ext_enc, _S_max_size);
      _M_ext_bom = __obj._M_ext_bom;
      _M_int_bom = __obj._M_int_bom;
      _M_destroy();
      _M_init();
      return *this;
    }

    ~__enc_traits()
    { _M_destroy(); }

    void
    _M_init()
    {
      const __desc_type __err = reinterpret_cast<iconv_t>(-1);
      if (!_M_in_desc)
 {
   _M_in_desc = iconv_open(_M_int_enc, _M_ext_enc);
   if (_M_in_desc == __err)
     __throw_runtime_error(("__enc_traits::_M_init " "creating iconv input descriptor failed"));

 }
      if (!_M_out_desc)
 {
   _M_out_desc = iconv_open(_M_ext_enc, _M_int_enc);
   if (_M_out_desc == __err)
     __throw_runtime_error(("__enc_traits::_M_init " "creating iconv output descriptor failed"));

 }
    }

    void
    _M_destroy()
    {
      const __desc_type __err = reinterpret_cast<iconv_t>(-1);
      if (_M_in_desc && _M_in_desc != __err)
 {
   iconv_close(_M_in_desc);
   _M_in_desc = 0;
 }
      if (_M_out_desc && _M_out_desc != __err)
 {
   iconv_close(_M_out_desc);
   _M_out_desc = 0;
 }
    }

    bool
    _M_good()
    {
      const __desc_type __err = reinterpret_cast<iconv_t>(-1);
      bool __test = _M_in_desc && _M_in_desc != __err;
      __test &= _M_out_desc && _M_out_desc != __err;
      return __test;
    }

    const __desc_type*
    _M_get_in_descriptor()
    { return &_M_in_desc; }

    const __desc_type*
    _M_get_out_descriptor()
    { return &_M_out_desc; }

    int
    _M_get_external_bom()
    { return _M_ext_bom; }

    int
    _M_get_internal_bom()
    { return _M_int_bom; }

    const char*
    _M_get_internal_enc()
    { return _M_int_enc; }

    const char*
    _M_get_external_enc()
    { return _M_ext_enc; }
  };




  template<typename _InternT, typename _ExternT>
    class codecvt<_InternT, _ExternT, __enc_traits>
    : public __codecvt_abstract_base<_InternT, _ExternT, __enc_traits>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef __enc_traits state_type;
      typedef __enc_traits::__desc_type __desc_type;
      typedef __enc_traits __enc_type;


      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
      { }

      explicit
      codecvt(__enc_type* __enc, size_t __refs = 0)
      : __codecvt_abstract_base<intern_type, extern_type, state_type>(__refs)
      { }

    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(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT>
    locale::id
    codecvt<_InternT, _ExternT, __enc_traits>::id;





  template<typename _T>
    inline size_t
    __iconv_adaptor(size_t(*__func)(iconv_t, _T, size_t*, char**, size_t*),
                    iconv_t __cd, char** __inbuf, size_t* __inbytes,
                    char** __outbuf, size_t* __outbytes)
    { return __func(__cd, (_T)__inbuf, __inbytes, __outbuf, __outbytes); }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    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
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
 {
   typedef state_type::__desc_type __desc_type;
   const __desc_type* __desc = __state._M_get_out_descriptor();
   const size_t __fmultiple = sizeof(intern_type);
   size_t __fbytes = __fmultiple * (__from_end - __from);
   const size_t __tmultiple = sizeof(extern_type);
   size_t __tbytes = __tmultiple * (__to_end - __to);



   char* __cto = reinterpret_cast<char*>(__to);
   char* __cfrom;
   size_t __conv;






   int __int_bom = __state._M_get_internal_bom();
   if (__int_bom)
     {
       size_t __size = __from_end - __from;
       intern_type* __cfixed = static_cast<intern_type*>(__builtin_alloca(sizeof(intern_type) * (__size + 1)));
       __cfixed[0] = static_cast<intern_type>(__int_bom);
       char_traits<intern_type>::copy(__cfixed + 1, __from, __size);
       __cfrom = reinterpret_cast<char*>(__cfixed);
       __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                        &__fbytes, &__cto, &__tbytes);
     }
   else
     {
       intern_type* __cfixed = const_cast<intern_type*>(__from);
       __cfrom = reinterpret_cast<char*>(__cfixed);
       __conv = __iconv_adaptor(iconv, *__desc, &__cfrom, &__fbytes,
           &__cto, &__tbytes);
     }

   if (__conv != size_t(-1))
     {
       __from_next = reinterpret_cast<const intern_type*>(__cfrom);
       __to_next = reinterpret_cast<extern_type*>(__cto);
       __ret = codecvt_base::ok;
     }
   else
     {
       if (__fbytes < __fmultiple * (__from_end - __from))
  {
    __from_next = reinterpret_cast<const intern_type*>(__cfrom);
    __to_next = reinterpret_cast<extern_type*>(__cto);
    __ret = codecvt_base::partial;
  }
       else
  __ret = codecvt_base::error;
     }
 }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_unshift(state_type& __state, extern_type* __to,
        extern_type* __to_end, extern_type*& __to_next) const
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
 {
   typedef state_type::__desc_type __desc_type;
   const __desc_type* __desc = __state._M_get_in_descriptor();
   const size_t __tmultiple = sizeof(intern_type);
   size_t __tlen = __tmultiple * (__to_end - __to);



   char* __cto = reinterpret_cast<char*>(__to);
   size_t __conv = __iconv_adaptor(iconv,*__desc, __null, __null,
                                          &__cto, &__tlen);

   if (__conv != size_t(-1))
     {
       __to_next = reinterpret_cast<extern_type*>(__cto);
       if (__tlen == __tmultiple * (__to_end - __to))
  __ret = codecvt_base::noconv;
       else if (__tlen == 0)
  __ret = codecvt_base::ok;
       else
  __ret = codecvt_base::partial;
     }
   else
     __ret = codecvt_base::error;
 }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    codecvt_base::result
    codecvt<_InternT, _ExternT, __enc_traits>::
    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
    {
      result __ret = codecvt_base::error;
      if (__state._M_good())
 {
   typedef state_type::__desc_type __desc_type;
   const __desc_type* __desc = __state._M_get_in_descriptor();
   const size_t __fmultiple = sizeof(extern_type);
   size_t __flen = __fmultiple * (__from_end - __from);
   const size_t __tmultiple = sizeof(intern_type);
   size_t __tlen = __tmultiple * (__to_end - __to);



   char* __cto = reinterpret_cast<char*>(__to);
   char* __cfrom;
   size_t __conv;






   int __ext_bom = __state._M_get_external_bom();
   if (__ext_bom)
     {
       size_t __size = __from_end - __from;
       extern_type* __cfixed = static_cast<extern_type*>(__builtin_alloca(sizeof(extern_type) * (__size + 1)));
       __cfixed[0] = static_cast<extern_type>(__ext_bom);
       char_traits<extern_type>::copy(__cfixed + 1, __from, __size);
       __cfrom = reinterpret_cast<char*>(__cfixed);
       __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                       &__flen, &__cto, &__tlen);
     }
   else
     {
       extern_type* __cfixed = const_cast<extern_type*>(__from);
       __cfrom = reinterpret_cast<char*>(__cfixed);
       __conv = __iconv_adaptor(iconv, *__desc, &__cfrom,
                                       &__flen, &__cto, &__tlen);
     }


   if (__conv != size_t(-1))
     {
       __from_next = reinterpret_cast<const extern_type*>(__cfrom);
       __to_next = reinterpret_cast<intern_type*>(__cto);
       __ret = codecvt_base::ok;
     }
   else
     {
       if (__flen < static_cast<size_t>(__from_end - __from))
  {
    __from_next = reinterpret_cast<const extern_type*>(__cfrom);
    __to_next = reinterpret_cast<intern_type*>(__cto);
    __ret = codecvt_base::partial;
  }
       else
  __ret = codecvt_base::error;
     }
 }
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_encoding() const throw()
    {
      int __ret = 0;
      if (sizeof(_ExternT) <= sizeof(_InternT))
 __ret = sizeof(_InternT)/sizeof(_ExternT);
      return __ret;
    }

  template<typename _InternT, typename _ExternT>
    bool
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_always_noconv() const throw()
    { return false; }

  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_length(state_type&, const extern_type* __from,
       const extern_type* __end, size_t __max) const
    { return std::min(__max, static_cast<size_t>(__end - __from)); }



  template<typename _InternT, typename _ExternT>
    int
    codecvt<_InternT, _ExternT, __enc_traits>::
    do_max_length() const throw()
    { return 1; }
# 476 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/codecvt.h" 2 3
# 1538 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 2 3


  class __num_base
  {
  public:


    enum
      {
        _S_ominus,
        _S_oplus,
        _S_ox,
        _S_oX,
        _S_odigits,
        _S_odigits_end = _S_odigits + 16,
        _S_oudigits = _S_odigits_end,
        _S_oudigits_end = _S_oudigits + 16,
        _S_oe = _S_odigits + 14,
        _S_oE = _S_oudigits + 14,
 _S_oend = _S_oudigits_end
      };






    static const char* _S_atoms_out;



    static const char* _S_atoms_in;

    enum
    {
      _S_iminus,
      _S_iplus,
      _S_ix,
      _S_iX,
      _S_izero,
      _S_ie = _S_izero + 14,
      _S_iE = _S_izero + 20,
      _S_iend = 26
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod);
  };

  template<typename _CharT>
    struct __numpunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      const _CharT* _M_truename;
      size_t _M_truename_size;
      const _CharT* _M_falsename;
      size_t _M_falsename_size;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;





      _CharT _M_atoms_out[__num_base::_S_oend];





      _CharT _M_atoms_in[__num_base::_S_iend];

      bool _M_allocated;

      __numpunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
      _M_falsename_size(0), _M_decimal_point(_CharT()),
      _M_thousands_sep(_CharT()), _M_allocated(false)
      { }

      ~__numpunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __numpunct_cache&
      operator=(const __numpunct_cache&);

      explicit
      __numpunct_cache(const __numpunct_cache&);
    };

  template<typename _CharT>
    __numpunct_cache<_CharT>::~__numpunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_truename;
   delete [] _M_falsename;
 }
    }
# 1660 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __numpunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;

    public:

      static locale::id id;






      explicit
      numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(); }
# 1697 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1711 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(__cloc); }
# 1725 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1738 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1769 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1782 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1795 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1812 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1824 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1837 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1850 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1863 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_falsename() const
      { return _M_data->_M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<>
    numpunct<char>::~numpunct();

  template<>
    void
    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);


  template<>
    numpunct<wchar_t>::~numpunct();

  template<>
    void
    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);


  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* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_numpunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~numpunct_byname() { }
    };
# 1928 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 1949 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1975 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, bool& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2011 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned short& __v) const
      { return this->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 this->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 this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long long& __v) const
      { return this->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 long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2070 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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 this->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 this->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 this->do_get(__in, __end, __io, __err, __v); }
# 2112 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    protected:

      virtual ~num_get() { }

      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
         string& __xtrc) const;

      template<typename _ValueT>
        iter_type
        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT& __v) const;
# 2145 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      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&, 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,
      long long&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      unsigned long 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;
# 2207 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 2228 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2246 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2288 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   unsigned long __v) const
      { return this->do_put(__s, __f, __fill, __v); }


      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   unsigned long long __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2351 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
      { return this->do_put(__s, __f, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2376 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __f, __fill, __v); }

    protected:
      template<typename _ValueT>
        iter_type
        _M_insert_float(iter_type, ios_base& __io, char_type __fill,
   char __mod, _ValueT __v) const;

      void
      _M_group_float(const char* __grouping, size_t __grouping_size,
       char_type __sep, const char_type* __p, char_type* __new,
       char_type* __cs, int& __len) const;

      template<typename _ValueT>
        iter_type
        _M_insert_int(iter_type, ios_base& __io, char_type __fill,
        _ValueT __v) const;

      void
      _M_group_int(const char* __grouping, size_t __grouping_size,
     char_type __sep, ios_base& __io, char_type* __new,
     char_type* __cs, int& __len) const;

      void
      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
      char_type* __new, const char_type* __cs, int& __len) const;


      virtual
      ~num_put() { };
# 2424 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      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, long long __v) const;

      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, unsigned long 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;
# 2468 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT>
    class collate : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_collate;

    public:

      static locale::id id;
# 2495 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 2509 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 2526 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 2545 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 2559 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const;

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const;

  protected:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 2588 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 2604 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 2617 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const;

  template<>
    size_t
    collate<char>::_M_transform(char*, const char*, size_t) const;


  template<>
    int
    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;

  template<>
    size_t
    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;


  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* __s, size_t __refs = 0)
      : collate<_CharT>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_collate);
     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
   }
      }

    protected:
      virtual
      ~collate_byname() { }
    };
# 2676 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
      _M_time_era_format(__null), _M_date_time_format(__null),
      _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
      _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
      _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
      _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
      _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
      _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
      _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
      _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
      _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
      _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
      _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
      _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
      { }

      ~__timepunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __timepunct_cache&
      operator=(const __timepunct_cache&);

      explicit
      __timepunct_cache(const __timepunct_cache&);
    };

  template<typename _CharT>
    __timepunct_cache<_CharT>::~__timepunct_cache()
    {
      if (_M_allocated)
 {

 }
    }


  template<>
    const char*
    __timepunct_cache<char>::_S_timezones[14];


  template<>
    const wchar_t*
    __timepunct_cache<wchar_t>::_S_timezones[14];



  template<typename _CharT>
    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef basic_string<_CharT> __string_type;
      typedef __timepunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;
      __c_locale _M_c_locale_timepunct;
      const char* _M_name_timepunct;

    public:

      static locale::id id;

      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__cache_type* __cache, size_t __refs = 0);
# 2834 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);

      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const;

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }

      void
      _M_am_pm_format(const _CharT* __ampm) const
      { __ampm = _M_data->_M_am_pm_format; }

      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const;



# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/time_members.h" 1 3
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/time_members.h" 3
  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
    _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
    _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
         size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
    _M_name_timepunct(__s)
    {
      char* __tmp = new char[std::strlen(__s) + 1];
      std::strcpy(__tmp, __s);
      _M_name_timepunct = __tmp;
      _M_initialize_timepunct(__cloc);
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {
      if (_M_name_timepunct != _S_get_c_name())
 delete [] _M_name_timepunct;
      delete _M_data;
      _S_destroy_c_locale(_M_c_locale_timepunct);
    }
# 2968 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 2 3
# 2981 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;

      typedef basic_string<_CharT> __string_type;


      static locale::id id;
# 3003 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 3020 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 3044 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 3069 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 3097 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 3126 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 3152 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }

    protected:

      virtual
      ~time_get() { }
# 3172 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual dateorder
      do_date_order() const;
# 3190 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 3209 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 3228 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 3247 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 3266 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;


      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;



      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format) const;
    };

  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() { }
    };
# 3321 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 3342 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 3361 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 3381 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:

      virtual
      ~time_put()
      { }
# 3408 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  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() { }
    };
# 3445 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn);
  };

  template<typename _CharT, bool _Intl>
    struct __moneypunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;
      const _CharT* _M_curr_symbol;
      size_t _M_curr_symbol_size;
      const _CharT* _M_positive_sign;
      size_t _M_positive_sign_size;
      const _CharT* _M_negative_sign;
      size_t _M_negative_sign_size;
      int _M_frac_digits;
      money_base::pattern _M_pos_format;
      money_base::pattern _M_neg_format;




      _CharT _M_atoms[money_base::_S_end];

      bool _M_allocated;

      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
      _M_curr_symbol(__null), _M_curr_symbol_size(0),
      _M_positive_sign(__null), _M_positive_sign_size(0),
      _M_negative_sign(__null), _M_negative_sign_size(0),
      _M_frac_digits(0),
      _M_pos_format(money_base::pattern()),
      _M_neg_format(money_base::pattern()), _M_allocated(false)
      { }

      ~__moneypunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __moneypunct_cache&
      operator=(const __moneypunct_cache&);

      explicit
      __moneypunct_cache(const __moneypunct_cache&);
    };

  template<typename _CharT, bool _Intl>
    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_curr_symbol;
   delete [] _M_positive_sign;
   delete [] _M_negative_sign;
 }
    }







  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

    private:
      __cache_type* _M_data;

    public:


      static const bool intl = _Intl;

      static locale::id id;
# 3566 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(); }
# 3578 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 3593 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(__cloc, __s); }
# 3607 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 3620 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 3649 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 3662 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 3679 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 3696 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 3712 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 3747 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 3769 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 3781 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 3794 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 3807 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 3820 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 3833 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 3847 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 3861 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 3875 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = __null,
    const char* __name = __null);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<>
    moneypunct<char, true>::~moneypunct();

  template<>
    moneypunct<char, false>::~moneypunct();

  template<>
    void
    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);

  template<>
    void
    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);


  template<>
    moneypunct<wchar_t, true>::~moneypunct();

  template<>
    moneypunct<wchar_t, false>::~moneypunct();

  template<>
    void
    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
       const char*);

  template<>
    void
    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
        const char*);


  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* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;
# 3965 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  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;
# 3987 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 4017 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 4047 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 4064 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 4075 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;

      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 4100 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  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;
# 4121 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 4141 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 4163 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 4191 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 4213 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;

      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;




  struct messages_base
  {
    typedef int catalog;
  };
# 4254 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 4282 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      messages(size_t __refs = 0);
# 4296 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 4309 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 4327 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 4345 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 4356 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 4376 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 4395 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {
# 4452 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 3
 return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;


  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* __s, size_t __refs = 0);

    protected:
      virtual
      ~messages_byname()
      { }
    };


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/messages_members.h" 1 3
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/messages_members.h" 3
  template<typename _CharT>
     messages<_CharT>::messages(size_t __refs)
     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
     _M_name_messages(_S_get_c_name())
     { }

  template<typename _CharT>
     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
    size_t __refs)
     : facet(__refs), _M_c_locale_messages(_S_clone_c_locale(__cloc)),
     _M_name_messages(__s)
     {
       char* __tmp = new char[std::strlen(__s) + 1];
       std::strcpy(__tmp, __s);
       _M_name_messages = __tmp;
     }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
      const char* __dir) const
    {
      bindtextdomain(__s.c_str(), __dir);
      return this->do_open(__s, __loc);
    }


  template<typename _CharT>
    messages<_CharT>::~messages()
    {
      if (_M_name_messages != _S_get_c_name())
 delete [] _M_name_messages;
      _S_destroy_c_locale(_M_c_locale_messages);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::do_open(const basic_string<char>& __s,
         const locale&) const
    {


      textdomain(__s.c_str());
      return 0;
    }

  template<typename _CharT>
    void
    messages<_CharT>::do_close(catalog) const
    { }


   template<typename _CharT>
     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
     : messages<_CharT>(__refs)
     {
       if (this->_M_name_messages != locale::facet::_S_get_c_name())
  delete [] this->_M_name_messages;
       char* __tmp = new char[std::strlen(__s) + 1];
       std::strcpy(__tmp, __s);
       this->_M_name_messages = __tmp;

       if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
  {
    this->_S_destroy_c_locale(this->_M_c_locale_messages);
    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
  }
     }
# 4488 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.h" 2 3
# 4496 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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); }

}
# 45 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/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;
# 78 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      typedef ctype<_CharT> __ctype_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
           __num_put_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
           __num_get_type;



    protected:
      basic_ostream<_CharT, _Traits>* _M_tie;
      mutable char_type _M_fill;
      mutable bool _M_fill_init;
      basic_streambuf<_CharT, _Traits>* _M_streambuf;


      const __ctype_type* _M_ctype;

      const __num_put_type* _M_num_put;

      const __num_get_type* _M_num_get;

    public:







      operator void*() const
      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }

      bool
      operator!() const
      { return this->fail(); }
# 122 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 133 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      void
      clear(iostate __state = goodbit);







      void
      setstate(iostate __state)
      { this->clear(this->rdstate() | __state); }




      void
      _M_setstate(iostate __state)
      {


 _M_streambuf_state |= __state;
 if (this->exceptions() & __state)
   throw;
      }







      bool
      good() const
      { return this->rdstate() == 0; }







      bool
      eof() const
      { return (this->rdstate() & eofbit) != 0; }
# 186 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 207 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 242 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      void
      exceptions(iostate __except)
      {
        _M_exception = __except;
        this->clear(_M_streambuf_state);
      }







      explicit
      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
      _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { this->init(__sb); }







      virtual
      ~basic_ios() { }
# 280 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 292 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie(basic_ostream<_CharT, _Traits>* __tiestr)
      {
        basic_ostream<_CharT, _Traits>* __old = _M_tie;
        _M_tie = __tiestr;
        return __old;
      }







      basic_streambuf<_CharT, _Traits>*
      rdbuf() const
      { return _M_streambuf; }
# 332 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 346 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      basic_ios&
      copyfmt(const basic_ios& __rhs);







      char_type
      fill() const
      {
 if (!_M_fill_init)
   {
     _M_fill = this->widen(' ');
     _M_fill_init = true;
   }
 return _M_fill;
      }
# 375 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 395 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 415 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const;
# 433 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 3
      char_type
      widen(char __c) const;

    protected:







      basic_ios()
      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
      _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
      { }







      void
      init(basic_streambuf<_CharT, _Traits>* __sb);

      void
      _M_cache_locale(const locale& __loc);
    };
}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.tcc" 1 3
# 33 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.tcc" 3
       
# 34 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.tcc" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
   _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != &__rhs)
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    char
    basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
    { return __check_facet(_M_ctype).narrow(__c, __dfault); }

  template<typename _CharT, typename _Traits>
    _CharT
    basic_ios<_CharT, _Traits>::widen(char __c) const
    { return __check_facet(_M_ctype).widen(__c); }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 159 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.tcc" 3
      _M_fill = _CharT();
      _M_fill_init = false;

      _M_tie = 0;
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
    {
      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
 _M_ctype = &use_facet<__ctype_type>(__loc);
      else
 _M_ctype = 0;

      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
 _M_num_put = &use_facet<__num_put_type>(__loc);
      else
 _M_num_put = 0;

      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
 _M_num_get = &use_facet<__num_get_type>(__loc);
      else
 _M_num_get = 0;
    }





  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;


}
# 465 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/basic_ios.h" 2 3
# 52 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ios" 2 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 2 3

namespace std
{
# 57 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
  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 num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
             __num_put_type;
      typedef ctype<_CharT> __ctype_type;

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, char);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, const char*);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
# 104 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 130 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      inline __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&));

      inline __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&));

      inline __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&));
# 167 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __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)); }


      __ostream_type&
      operator<<(long long __n);

      __ostream_type&
      operator<<(unsigned long long __n);


      __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);
# 248 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 281 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __ostream_type&
      put(char_type __c);


      void
      _M_write(const char_type* __s, streamsize __n)
      {
 streamsize __put = this->rdbuf()->sputn(__s, __n);
 if (__put != __n)
   this->setstate(ios_base::badbit);
      }
# 309 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 322 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __ostream_type&
      flush();
# 333 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      pos_type
      tellp();
# 344 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 356 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      explicit
      basic_ostream() { }
    };
# 374 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT,_Traits>& _M_os;

    public:
# 393 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      explicit
      sentry(basic_ostream<_CharT,_Traits>& __os);
# 403 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      ~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);
   }
      }
# 421 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 442 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
  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)); }
# 482 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
  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)); }
# 516 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 3
  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(_CharT()); }






  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ostream.tcc" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ostream.tcc" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ostream.tcc" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/locale" 1 3
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/locale" 3
       
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/locale" 3




# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 1 3
# 36 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
       
# 37 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/typeinfo" 1 3
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/typeinfo" 3
extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 55 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/typeinfo" 3
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:



    const char* name() const
    { return __name; }
# 101 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/typeinfo" 3
    bool before(const type_info& __arg) const
    { return __name < __arg.__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();
  };
}

}
# 40 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 2 3


namespace std
{
  template<typename _Facet>
    locale
    locale::combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      return locale(__tmp);
    }

  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& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }
# 83 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
  template<typename _Facet>
    inline bool
    has_facet(const locale& __loc) throw()
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size && __facets[__i]);
    }
# 105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
  template<typename _Facet>
    inline const _Facet&
    use_facet(const locale& __loc)
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      if (!(__i < __loc._M_impl->_M_facets_size && __facets[__i]))
        __throw_bad_cast();
      return static_cast<const _Facet&>(*__facets[__i]);
    }



  template<typename _Facet>
    struct __use_cache
    {
      const _Facet*
      operator() (const locale& __loc) const;
    };


  template<typename _CharT>
    struct __use_cache<__numpunct_cache<_CharT> >
    {
      const __numpunct_cache<_CharT>*
      operator() (const locale& __loc) const
      {
 const size_t __i = numpunct<_CharT>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __numpunct_cache<_CharT>* __tmp = __null;
     try
       {
  __tmp = new __numpunct_cache<_CharT>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
      }
    };

  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT>
    void
    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

      _M_grouping_size = __np.grouping().size();
      char* __grouping = new char[_M_grouping_size];
      __np.grouping().copy(__grouping, _M_grouping_size);
      _M_grouping = __grouping;
      _M_use_grouping = _M_grouping_size && __np.grouping()[0] != 0;

      _M_truename_size = __np.truename().size();
      _CharT* __truename = new _CharT[_M_truename_size];
      __np.truename().copy(__truename, _M_truename_size);
      _M_truename = __truename;

      _M_falsename_size = __np.falsename().size();
      _CharT* __falsename = new _CharT[_M_falsename_size];
      __np.falsename().copy(__falsename, _M_falsename_size);
      _M_falsename = __falsename;

      _M_decimal_point = __np.decimal_point();
      _M_thousands_sep = __np.thousands_sep();

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(__num_base::_S_atoms_out,
   __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out);
      __ct.widen(__num_base::_S_atoms_in,
   __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);
    }

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      _M_grouping_size = __mp.grouping().size();
      char* __grouping = new char[_M_grouping_size];
      __mp.grouping().copy(__grouping, _M_grouping_size);
      _M_grouping = __grouping;
      _M_use_grouping = _M_grouping_size && __mp.grouping()[0] != 0;

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();
      _M_frac_digits = __mp.frac_digits();

      _M_curr_symbol_size = __mp.curr_symbol().size();
      _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
      __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
      _M_curr_symbol = __curr_symbol;

      _M_positive_sign_size = __mp.positive_sign().size();
      _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
      __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
      _M_positive_sign = __positive_sign;

      _M_negative_sign_size = __mp.negative_sign().size();
      _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
      __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
      _M_negative_sign = __negative_sign;

      _M_pos_format = __mp.pos_format();
      _M_neg_format = __mp.neg_format();

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(money_base::_S_atoms,
   money_base::_S_atoms + money_base::_S_end, _M_atoms);
    }
# 266 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
  static bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp);

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, string& __xtrc) const
    {
      typedef char_traits<_CharT> __traits_type;
      typedef typename numpunct<_CharT>::__cache_type __cache_type;
      __use_cache<__cache_type> __uc;
      const locale& __loc = __io._M_getloc();
      const __cache_type* __lc = __uc(__loc);
      const _CharT* __lit = __lc->_M_atoms_in;


      bool __found_mantissa = false;


      if (__beg != __end)
 {
   const char_type __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
     {
       __xtrc += __plus ? '+' : '-';
       ++__beg;
     }
 }


      while (__beg != __end)
 {
   const char_type __c = *__beg;
   if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
       || __c == __lc->_M_decimal_point)
     break;
   else if (__c == __lit[__num_base::_S_izero])
     {
       if (!__found_mantissa)
  {
    __xtrc += '0';
    __found_mantissa = true;
  }
       ++__beg;
     }
   else
     break;
 }


      bool __found_dec = false;
      bool __found_sci = false;
      string __found_grouping;
      if (__lc->_M_use_grouping)
 __found_grouping.reserve(32);
      int __sep_pos = 0;
      const char_type* __lit_zero = __lit + __num_base::_S_izero;
      const char_type* __q;
      while (__beg != __end)
        {


   const char_type __c = *__beg;
          if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
     {
       if (!__found_dec && !__found_sci)
  {


    if (__sep_pos)
      {
        __found_grouping += static_cast<char>(__sep_pos);
        __sep_pos = 0;
        ++__beg;
      }
    else
      {
        __err |= ios_base::failbit;
        break;
      }
  }
       else
  break;
            }
   else if (__c == __lc->_M_decimal_point)
     {
       if (!__found_dec && !__found_sci)
  {



    if (__found_grouping.size())
      __found_grouping += static_cast<char>(__sep_pos);
    __xtrc += '.';
    __found_dec = true;
    ++__beg;
  }
       else
  break;
     }
          else if (__q = __traits_type::find(__lit_zero, 10, __c))
     {
       __xtrc += __num_base::_S_atoms_in[__q - __lit];
       __found_mantissa = true;
       ++__sep_pos;
       ++__beg;
     }
   else if ((__c == __lit[__num_base::_S_ie]
      || __c == __lit[__num_base::_S_iE])
     && __found_mantissa && !__found_sci)
     {

       if (__found_grouping.size() && !__found_dec)
  __found_grouping += static_cast<char>(__sep_pos);
       __xtrc += 'e';
       __found_sci = true;


       if (++__beg != __end)
  {
    const bool __plus = *__beg == __lit[__num_base::_S_iplus];
    if ((__plus || *__beg == __lit[__num_base::_S_iminus])
        && !(__lc->_M_use_grouping
      && *__beg == __lc->_M_thousands_sep)
        && !(*__beg == __lc->_M_decimal_point))
      {
        __xtrc += __plus ? '+' : '-';
        ++__beg;
      }
  }
     }
   else

     break;
        }



      if (__lc->_M_use_grouping && __found_grouping.size())
        {

   if (!__found_dec && !__found_sci)
     __found_grouping += static_cast<char>(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,
          __lc->_M_grouping_size,
          __found_grouping))
     __err |= ios_base::failbit;
        }


      if (__beg == __end)
        __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    template<typename _ValueT>
      _InIter
      num_get<_CharT, _InIter>::
      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, _ValueT& __v) const
      {
        typedef char_traits<_CharT> __traits_type;
 typedef typename numpunct<_CharT>::__cache_type __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_in;


 const ios_base::fmtflags __basefield = __io.flags()
                                        & ios_base::basefield;
 const bool __oct = __basefield == ios_base::oct;
 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);


 bool __found_num = false;


 bool __negative = false;
 if (__beg != __end)
   {
     const char_type __c = *__beg;
     if (numeric_limits<_ValueT>::is_signed)
       __negative = __c == __lit[__num_base::_S_iminus];
     if ((__negative || __c == __lit[__num_base::_S_iplus])
  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  && !(__c == __lc->_M_decimal_point))
       ++__beg;
   }



 while (__beg != __end)
   {
     const char_type __c = *__beg;
     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep
  || __c == __lc->_M_decimal_point)
       break;
     else if (__c == __lit[__num_base::_S_izero]
       && (!__found_num || __base == 10))
       {
  __found_num = true;
  ++__beg;
       }
     else if (__found_num)
       {
  if (__c == __lit[__num_base::_S_ix]
      || __c == __lit[__num_base::_S_iX])
    {
      if (__basefield == 0)
        __base = 16;
      if (__base == 16)
        {
   __found_num = false;
   ++__beg;
        }
    }
  else if (__basefield == 0)
    __base = 8;
  break;
       }
     else
       break;
   }



 const size_t __len = __base == 16 ? (__num_base::_S_iend
          - __num_base::_S_izero)
                                   : __base;


 string __found_grouping;
 if (__lc->_M_use_grouping)
   __found_grouping.reserve(32);
 int __sep_pos = 0;
 bool __overflow = false;
 _ValueT __result = 0;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;
 const char_type* __q;
 if (__negative)
   {
     const _ValueT __min = numeric_limits<_ValueT>::min() / __base;
     for (; __beg != __end; ++__beg)
       {


  const char_type __c = *__beg;
  if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
    {


      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {
   __err |= ios_base::failbit;
   break;
        }
    }
  else if (__c == __lc->_M_decimal_point)
    break;
  else if (__q = __traits_type::find(__lit_zero, __len, __c))
    {
      int __digit = __q - __lit_zero;
      if (__digit > 15)
        __digit -= 6;
      if (__result < __min)
        __overflow = true;
      else
        {
   const _ValueT __new_result = __result * __base
                                - __digit;
   __overflow |= __new_result > __result;
   __result = __new_result;
   ++__sep_pos;
   __found_num = true;
        }
    }
  else

    break;
       }
   }
 else
   {
     const _ValueT __max = numeric_limits<_ValueT>::max() / __base;
     for (; __beg != __end; ++__beg)
       {
  const char_type __c = *__beg;
  if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
    {
      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {
   __err |= ios_base::failbit;
   break;
        }
    }
  else if (__c == __lc->_M_decimal_point)
    break;
  else if (__q = __traits_type::find(__lit_zero, __len, __c))
    {
      int __digit = __q - __lit_zero;
      if (__digit > 15)
        __digit -= 6;
      if (__result > __max)
        __overflow = true;
      else
        {
   const _ValueT __new_result = __result * __base
                                + __digit;
   __overflow |= __new_result < __result;
   __result = __new_result;
   ++__sep_pos;
   __found_num = true;
        }
    }
  else
    break;
       }
   }



 if (__lc->_M_use_grouping && __found_grouping.size())
   {

     __found_grouping += static_cast<char>(__sep_pos);

     if (!std::__verify_grouping(__lc->_M_grouping,
     __lc->_M_grouping_size,
     __found_grouping))
       __err |= ios_base::failbit;
   }

 if (!(__err & ios_base::failbit) && !__overflow
     && __found_num)
   __v = __result;
 else
   __err |= ios_base::failbit;

 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, bool& __v) const
    {
      if (!(__io.flags() & ios_base::boolalpha))
        {



   long __l = -1;
          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
   if (__l == 0 || __l == 1)
     __v = __l;
   else
            __err |= ios_base::failbit;
        }
      else
        {

   typedef char_traits<_CharT> __traits_type;
   typedef typename numpunct<_CharT>::__cache_type __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   bool __testf = true;
   bool __testt = true;
   size_t __n;
          for (__n = 0; __beg != __end; ++__n, ++__beg)
            {
       if (__testf)
  if (__n < __lc->_M_falsename_size)
    __testf = *__beg == __lc->_M_falsename[__n];
  else
    break;

       if (__testt)
  if (__n < __lc->_M_truename_size)
    __testt = *__beg == __lc->_M_truename[__n];
  else
    break;

       if (!__testf && !__testt)
  break;
            }
   if (__testf && __n == __lc->_M_falsename_size)
     __v = 0;
   else if (__testt && __n == __lc->_M_truename_size)
     __v = 1;
   else
     __err |= ios_base::failbit;

          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, long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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
    { return _M_extract_int(__beg, __end, __io, __err, __v); }


  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 long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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 long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }


  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
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      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
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      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
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      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, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      const fmtflags __fmt = __io.flags();
      __io.flags(__fmt & ~ios_base::basefield | ios_base::hex);

      unsigned long __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      if (!(__err & ios_base::failbit))
 __v = reinterpret_cast<void*>(__ul);
      else
 __err |= ios_base::failbit;
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, __cs,
        __w, __len, true);
      __len = static_cast<int>(__w);
    }


  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    {
      unsigned long __ul = static_cast<unsigned long>(__v);
      bool __neg = false;
      if (__v < 0)
 {
   __ul = -__ul;
   __neg = true;
 }
      return __int_to_char(__bufend, __ul, __lit, __flags, __neg);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    {

      return __int_to_char(__bufend, __v, __lit,
      __flags & ~ios_base::showpos, false);
    }


  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    {
      unsigned long long __ull = static_cast<unsigned long long>(__v);
      bool __neg = false;
      if (__v < 0)
 {
   __ull = -__ull;
   __neg = true;
 }
      return __int_to_char(__bufend, __ull, __lit, __flags, __neg);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, unsigned long long __v,
    const _CharT* __lit, ios_base::fmtflags __flags)
    { return __int_to_char(__bufend, __v, __lit,
      __flags & ~ios_base::showpos, false); }


  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __neg)
    {

      const bool __showbase = (__flags & ios_base::showbase) && __v;
      const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
      _CharT* __buf = __bufend - 1;

      if (__builtin_expect(__basefield != ios_base::oct &&
      __basefield != ios_base::hex, true))
 {

   do
     {
       *__buf-- = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
   if (__neg)
     *__buf-- = __lit[__num_base::_S_ominus];
   else if (__flags & ios_base::showpos)
     *__buf-- = __lit[__num_base::_S_oplus];
 }
      else if (__basefield == ios_base::oct)
 {

   do
     {
       *__buf-- = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
   if (__showbase)
     *__buf-- = __lit[__num_base::_S_odigits];
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *__buf-- = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
   if (__showbase)
     {

       *__buf-- = __lit[__num_base::_S_ox + __uppercase];

       *__buf-- = __lit[__num_base::_S_odigits];
     }
 }
      return __bufend - __buf - 1;
    }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base& __io, _CharT* __new, _CharT* __cs, int& __len) const
    {





      streamsize __off = 0;
      const ios_base::fmtflags __basefield = __io.flags()
                                      & ios_base::basefield;
      if ((__io.flags() & ios_base::showbase) && __len > 1)
 if (__basefield == ios_base::oct)
   {
     __off = 1;
     __new[0] = __cs[0];
   }
 else if (__basefield == ios_base::hex)
   {
     __off = 2;
     __new[0] = __cs[0];
     __new[1] = __cs[1];
   }
      _CharT* __p;
      __p = std::__add_grouping(__new + __off, __sep, __grouping,
    __grouping_size, __cs + __off,
    __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 typedef typename numpunct<_CharT>::__cache_type __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;


 const int __ilen = 4 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 int __len;
 __len = __int_to_char(__cs + __ilen, __v, __lit, __io.flags());
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2, __cs, __len);
     __cs = __cs2;
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      _CharT* __p2;
      const int __declen = __p ? __p - __cs : __len;
      __p2 = std::__add_grouping(__new, __sep, __grouping, __grouping_size,
     __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 1041 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
         _ValueT __v) const
      {
 typedef typename numpunct<_CharT>::__cache_type __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);


 streamsize __prec = __io.precision();
 if (__prec < static_cast<streamsize>(0))
   __prec = static_cast<streamsize>(6);

 const int __max_digits = numeric_limits<_ValueT>::digits10;


 int __len;

 char __fbuf[16];




 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));

 __num_base::_S_format_float(__io, __fbuf, __mod);
 __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
          _S_get_c_locale(), __prec);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
       _S_get_c_locale(), __prec);
   }
# 1105 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len));
      __ctype.widen(__cs, __cs + __len, __ws);


      const _CharT __cdec = __ctype.widen('.');
      const _CharT __dec = __lc->_M_decimal_point;
      const _CharT* __p;
      if (__p = char_traits<_CharT>::find(__ws, __len, __cdec))
 __ws[__p - __ws] = __dec;


      if (__lc->_M_use_grouping)
 {


   _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
        * __len * 2));
   _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __p, __ws2, __ws, __len);
   __ws = __ws2;
 }


      const streamsize __w = __io.width();
      if (__w > static_cast<streamsize>(__len))
 {
   _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
        * __w));
   _M_pad(__fill, __w, __io, __ws3, __ws, __len);
   __ws = __ws3;
 }
      __io.width(0);



      return std::__write(__s, __ws, __len);
      }

  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 ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          const long __l = __v;
          __s = _M_insert_int(__s, __io, __fill, __l);
        }
      else
        {
   typedef typename numpunct<_CharT>::__cache_type __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   const _CharT* __name = __v ? __lc->_M_truename
                              : __lc->_M_falsename;
   int __len = __v ? __lc->_M_truename_size
                   : __lc->_M_falsename_size;

   const streamsize __w = __io.width();
   if (__w > static_cast<streamsize>(__len))
     {
       _CharT* __cs
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __w));
       _M_pad(__fill, __w, __io, __cs, __name, __len);
       __name = __cs;
     }
   __io.width(0);
   __s = std::__write(__s, __name, __len);
 }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }

  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 _M_insert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __b, char_type __fill, long long __v) const
    { return _M_insert_int(__s, __b, __fill, __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }

  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
    { return _M_insert_float(__s, __io, __fill, 'L', __v); }

  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
    {
      const ios_base::fmtflags __flags = __io.flags();
      const ios_base::fmtflags __fmt = ~(ios_base::basefield
      | ios_base::uppercase
      | ios_base::internal);
      __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<unsigned long>(__v));
      __io.flags(__flags);
      return __s;
    }

  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef moneypunct<_CharT, _Intl> __moneypunct_type;
 typedef typename __moneypunct_type::__cache_type __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const char_type* __q;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || __mandatory_sign
         && (static_cast<part>(__p.field[3])
      == money_base::sign))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, ++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    if (__q = __traits_type::find(__lit_zero, 10, *__beg))
      {
        __res += money_base::_S_atoms[__q - __lit];
        ++__n;
      }
    else if (*__beg == __lc->_M_decimal_point && !__testdecfound)
      {
        __last_pos = __n;
        __n = 0;
        __testdecfound = true;
      }
    else if (__lc->_M_use_grouping
      && *__beg == __lc->_M_thousands_sep
      && !__testdecfound)
      {
        if (__n)
   {

     __grouping_tmp += static_cast<char>(__n);
     __n = 0;
   }
        else
   {
     __testvalid = false;
     break;
   }
      }
    else
      break;
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;
       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, ++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __testvalid = false;
       }


     if (__testdecfound && __lc->_M_frac_digits > 0
  && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (__beg == __end)
   __err |= ios_base::eofbit;


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);

 return __beg;
      }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      if (__intl)
 __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
      else
 __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __units) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
       __err, __str)
                              : _M_extract<false>(__beg, __end, __io,
        __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __len));
   __ctype.widen(__str.data(), __str.data() + __len, __ws);
   __units.assign(__ws, __len);
 }

      return __ret;
    }

  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef moneypunct<_CharT, _Intl> __moneypunct_type;
 typedef typename __moneypunct_type::__cache_type __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (*__beg != __lit[money_base::_S_minus])
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     int __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
         {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
    if (__lc->_M_grouping_size)
      {
      _CharT* __ws =
          static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
             * 2 * __len));
        _CharT* __ws_end =
        std::__add_grouping(__ws, __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.assign(__ws, __ws_end - __ws);
      }
    else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
         }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
     _S_get_c_locale(), 0);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
     _S_get_c_locale(), 0);
 }







      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __cs_size));
      __ctype.widen(__cs, __cs + __len, __ws);
      const string_type __digits(__ws, __len);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }





  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':

    const char_type* __days1[7];
    __tp._M_days_abbreviated(__days1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
       7, __io, __err);
    break;
  case 'A':

    const char_type* __days2[7];
    __tp._M_days(__days2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
       7, __io, __err);
    break;
  case 'h':
  case 'b':

    const char_type* __months1[12];
    __tp._M_months_abbreviated(__months1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months1, 12, __io, __err);
    break;
  case 'B':

    const char_type* __months2[12];
    __tp._M_months(__months2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months2, 12, __io, __err);
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __dt[0]);
    break;
  case 'd':

    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
      __io, __err);
    break;
  case 'e':


    if (__ctype.is(ctype_base::space, *__beg))
      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
        1, __io, __err);
    else
      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
        2, __io, __err);
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
      __io, __err);
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
      __io, __err);
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __err);
    if (!__err)
      __tm->tm_mon = __mem - 1;
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
      __io, __err);
    break;
  case 'n':
    if (__ctype.narrow(*__beg, 0) == '\n')
      ++__beg;
    else
      __err |= ios_base::failbit;
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,



      __io, __err);
    break;
  case 't':
    if (__ctype.narrow(*__beg, 0) == '\t')
      ++__beg;
    else
      __err |= ios_base::failbit;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __dates[0]);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __times[0]);
    break;
  case 'y':
  case 'C':

    __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
      __io, __err);
    break;
  case 'Y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __err);
    if (!__err)
      __tm->tm_year = __mem - 1900;
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __err);


        if (__beg != __end && !__err && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __err);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __err);
   }
      }
    else
      __err |= ios_base::failbit;
    break;
  default:

    __err |= ios_base::failbit;
  }
     }
   else
     {

       if (__format[__i] == *__beg)
  ++__beg;
       else
  __err |= ios_base::failbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);

      ++__min;
      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, ++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       const int __valuec = __value * __mult;
       if (__valuec > __max || __valuec + __mult < __min)
  break;
       __mult /= 10;
     }
   else
     break;
 }
      if (__i == __len)
 __member = __value;
      else
 __err |= ios_base::failbit;
      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;





      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__c == __names[__i1][0]
  || __c == __ctype.toupper(__names[__i1][0]))
       __matches[__nmatches++] = __i1;
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __traits_type::length(__names[__matches[0]]);
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen,
         __traits_type::length(__names[__matches[__i2]]));
   ++__pos;
   ++__beg;
   if (__pos < __minlen && __beg != __end)
     for (size_t __i3 = 0; __i3 < __nmatches;)
       {
  __name = __names[__matches[__i3]];
  if (__name[__pos] != *__beg)
    __matches[__i3] = __matches[--__nmatches];
  else
    ++__i3;
       }
   else
     break;
 }

      if (__nmatches == 1)
 {

   ++__pos;
   ++__beg;
   __name = __names[__matches[0]];
   const size_t __len = __traits_type::length(__name);
   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
     ++__beg, ++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __days[7];
      __tp._M_days_abbreviated(__days);
      int __tmpwday;
      __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7, __io, __err);







      if (!__err)
 {
   size_t __pos = __traits_type::length(__days[__tmpwday]);
   __tp._M_days(__days);
   const char_type* __name = __days[__tmpwday];
   if (__name[__pos] == *__beg)
     {

       const size_t __len = __traits_type::length(__name);
       while (__pos < __len && __beg != __end
       && __name[__pos] == *__beg)
  ++__beg, ++__pos;
       if (__len != __pos)
  __err |= ios_base::failbit;
     }
   if (!__err)
     __tm->tm_wday = __tmpwday;
 }
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __months[12];
      __tp._M_months_abbreviated(__months);
      int __tmpmon;
      __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
         __io, __err);







      if (!__err)
 {
   size_t __pos = __traits_type::length(__months[__tmpmon]);
   __tp._M_months(__months);
   const char_type* __name = __months[__tmpmon];
   if (__name[__pos] == *__beg)
     {

       const size_t __len = __traits_type::length(__name);
       while (__pos < __len && __beg != __end
       && __name[__pos] == *__beg)
  ++__beg, ++__pos;
       if (__len != __pos)
  __err |= ios_base::failbit;
     }
   if (!__err)
     __tm->tm_mon = __tmpmon;
 }

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < 4; ++__beg, ++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     __value = __value * 10 + (__c - '0');
   else
     break;
 }
      if (__i == 2 || __i == 4)
 __tm->tm_year = __i == 2 ? __value : __value - 1900;
      else
 __err |= ios_base::failbit;
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type* __res =
       static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
        const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();




      for (;;)
 {
   const int __res = _M_compare(__p, __q);
   if (__res)
     return __res;

   __p += char_traits<_CharT>::length(__p);
   __q += char_traits<_CharT>::length(__q);
   if (__p == __pend && __q == __qend)
     return 0;
   else if (__p == __pend)
     return -1;
   else if (__q == __qend)
     return 1;

   __p++;
   __q++;
 }
    }

  template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {

      string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      string_type __ret;




      for (;;)
 {

   _CharT* __c =
     static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
   size_t __res = _M_transform(__c, __p, __len);


   if (__res >= __len)
     {
       __len = __res + 1;
       __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
         * __len));
       __res = _M_transform(__c, __p, __res + 1);
     }

   __ret.append(__c, __res);
   __p += char_traits<_CharT>::length(__p);
   if (__p == __pend)
     return __ret;

   __p++;
   __ret.push_back(_CharT());
 }
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val = *__lo + ((__val << 7) |
         (__val >> (numeric_limits<unsigned long>::digits - 7)));
      return static_cast<long>(__val);
    }
# 2389 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       const streamsize __newlen,
       const streamsize __oldlen, const bool __num)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, const_cast<_CharT*>(__olds), __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal && __num)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   const bool __testsign = (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0]);
   const bool __testhex = (__ctype.widen('0') == __olds[0]
      && __oldlen > 1
      && (__ctype.widen('x') == __olds[1]
          || __ctype.widen('X') == __olds[1]));
   if (__testhex)
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }
   else if (__testsign)
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
      __oldlen - __mod);
    }

  bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp)
  {
    const size_t __n = __grouping_tmp.size() - 1;
    const size_t __min = std::min(__n, __grouping_size - 1);
    size_t __i = __n;
    bool __test = true;




    for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
      __test = __grouping_tmp[__i] == __grouping[__j];
    for (; __i && __test; --__i)
      __test = __grouping_tmp[__i] == __grouping[__min];


    __test &= __grouping_tmp[0] <= __grouping[__min];
    return __test;
  }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      if (__last - __first > *__gbeg)
 {
   const bool __bump = __gsize != 1;
   __s = std::__add_grouping(__s, __sep, __gbeg + __bump,
        __gsize - __bump, __first,
        __last - *__gbeg);
   __first = __last - *__gbeg;
   *__s++ = __sep;
 }
      do
 *__s++ = *__first++;
      while (__first != __last);
      return __s;
    }





  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class money_get<char>;
  extern template class money_put<char>;
  extern template class numpunct<char>;
  extern template class numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;
  extern template class ctype_byname<char>;
  extern template class codecvt_byname<char, char, mbstate_t>;
  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class money_get<wchar_t>;
  extern template class money_put<wchar_t>;
  extern template class numpunct<wchar_t>;
  extern template class numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;
  extern template class ctype_byname<wchar_t>;
  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);


}
# 48 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/locale" 2 3
# 41 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/ostream.tcc" 2 3

namespace std
{
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ostream_type& (*__pf)(__ostream_type&))
    {



      return __pf(*this);
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ios_type& (*__pf)(__ios_type&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(ios_base& (*__pf)(ios_base&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(bool __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       bool __b = false;
       const char_type __c = this->fill();
       const ios_base::fmtflags __fmt = (this->flags()
      & ios_base::basefield);
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
  {
    const unsigned long __l = static_cast<unsigned long>(__n);
    __b = __np.put(*this, *this, __c, __l).failed();
  }
       else
  __b = __np.put(*this, *this, __c, __n).failed();
       if (__b)
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(unsigned long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       bool __b = false;
       const char_type __c = this->fill();
       const ios_base::fmtflags __fmt = (this->flags()
      & ios_base::basefield);
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
  {
    const unsigned long long __l = (static_cast<
        unsigned long long>(__n));
    __b = __np.put(*this, *this, __c, __l).failed();
  }
       else
  __b = __np.put(*this, *this, __c, __n).failed();
       if (__b)
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(unsigned long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(long double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(const void* __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const int_type __put = this->rdbuf()->sputc(__c);
       if (traits_type::eq_int_type(__put, traits_type::eof()))
  __err |= ios_base::badbit;
     }
   catch (...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   try
     { _M_write(__s, __n); }
   catch (...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {



      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
     __err |= ios_base::badbit;
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (!this->fail())
     {


       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
            ios_base::out);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = 1;
       _CharT* __cs = &__c;
       if (__w > __len)
  {
    __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __w));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       &__c, __w, __len, false);
    __len = __w;
  }
       __out._M_write(__cs, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = 1;
       char* __cs = &__c;
       if (__w > __len)
  {
    __cs = static_cast<char*>(__builtin_alloca(__w));
    __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
            &__c, __w, __len, false);
    __len = __w;
  }
       __out._M_write(__cs, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
     }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(_Traits::length(__s));
       if (__w > __len)
  {
    _CharT* __cs = (static_cast<
      _CharT*>(__builtin_alloca(sizeof(_CharT)
           * __w)));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __s, __w, __len, false);
    __s = __cs;
    __len = __w;
  }
       __out._M_write(__s, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;



      typedef char_traits<char> __traits_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   size_t __clen = __traits_type::length(__s);
   _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __clen));
   for (size_t __i = 0; __i < __clen; ++__i)
     __ws[__i] = __out.widen(__s[__i]);
   _CharT* __str = __ws;

   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(__clen);
       if (__w > __len)
  {
    _CharT* __cs = (static_cast<
      _CharT*>(__builtin_alloca(sizeof(_CharT)
           * __w)));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __ws, __w, __len, false);
    __str = __cs;
    __len = __w;
  }
       __out._M_write(__str, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(_Traits::length(__s));
       if (__w > __len)
  {
    char* __cs = static_cast<char*>(__builtin_alloca(__w));
    __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __s, __w, __len, false);
    __s = __cs;
    __len = __w;
  }
       __out._M_write(__s, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out,
        const basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   const streamsize __w = __out.width();
   streamsize __len = static_cast<streamsize>(__str.size());
   const _CharT* __s = __str.data();



   if (__w > __len)
     {
       _CharT* __cs = (static_cast<
         _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
       __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
          __w, __len, false);
       __s = __cs;
       __len = __w;
     }
   __out._M_write(__s, __len);
   __out.width(0);
 }
      return __out;
    }





  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);


}
# 546 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/ostream" 2 3
# 46 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 2 3
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3




namespace std
{
# 58 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  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 num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
        __num_get_type;
      typedef ctype<_CharT> __ctype_type;

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

    protected:







      streamsize _M_gcount;

    public:
# 104 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      explicit
      basic_istream(__streambuf_type* __sb): _M_gcount(streamsize(0))
      { this->init(__sb); }






      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;
# 131 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      inline __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&));

      inline __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&));

      inline __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&));
# 169 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __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);


      __istream_type&
      operator>>(long long& __n);

      __istream_type&
      operator>>(unsigned long long& __n);


      __istream_type&
      operator>>(float& __f);

      __istream_type&
      operator>>(double& __f);

      __istream_type&
      operator>>(long double& __f);

      __istream_type&
      operator>>(void*& __p);
# 230 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 240 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      inline streamsize
      gcount() const
      { return _M_gcount; }
# 272 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      int_type
      get();
# 286 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      get(char_type& __c);
# 313 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 324 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      inline __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 347 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 357 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      inline __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 386 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 397 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      inline __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 416 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      ignore(streamsize __n = 1, int_type __delim = traits_type::eof());
# 427 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      int_type
      peek();
# 445 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 464 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 480 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      putback(char_type __c);
# 495 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      unget();
# 513 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      int
      sync();
# 527 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      pos_type
      tellg();
# 542 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      seekg(pos_type);
# 558 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    protected:
      explicit
      basic_istream(): _M_gcount(streamsize(0)) { }
    };
# 578 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  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 typename __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;
# 610 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 620 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
      operator bool() const { return _M_ok; }

    private:
      bool _M_ok;
    };
# 639 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  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 >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 680 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  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)); }
# 702 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_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_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;







      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(), __ostream_type()
      { this->init(__sb); }




      virtual
      ~basic_iostream() { }

    protected:
      explicit
      basic_iostream() : __istream_type(), __ostream_type()
      { }
    };
# 765 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/istream.tcc" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/istream.tcc" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/istream.tcc" 3




namespace std
{
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      if (__in.good())
 {
   if (__in.tie())
     __in.tie()->flush();
   if (!__noskip && (__in.flags() & ios_base::skipws))
     {
       const __int_type __eof = traits_type::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       const __ctype_type& __ct = __check_facet(__in._M_ctype);
       while (!traits_type::eq_int_type(__c, __eof)
       && __ct.is(ctype_base::space,
    traits_type::to_char_type(__c)))
  __c = __sb->snextc();




       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
 }

      if (__in.good() && __err == ios_base::goodbit)
 _M_ok = true;
      else
 {
   __err |= ios_base::failbit;
   __in.setstate(__err);
 }
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__istream_type& (*__pf)(__istream_type&))
    { return __pf(*this); }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__ios_type& (*__pf)(__ios_type&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(ios_base& (*__pf)(ios_base&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(bool& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);


       if (!(__err & ios_base::failbit)
    && (numeric_limits<short>::min() <= __l
        && __l <= numeric_limits<short>::max()))
  __n = __l;
       else
                __err |= ios_base::failbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       long __l;
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __l);


       if (!(__err & ios_base::failbit)
    && (numeric_limits<int>::min() <= __l
        && __l <= numeric_limits<int>::max()))
  __n = __l;
       else
                __err |= ios_base::failbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(unsigned long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(float& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(long double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(void*& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
 {
   try
     {
       if (!__copy_streambufs(this->rdbuf(), __sbout))
  __err |= ios_base::failbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbout)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       __c = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__c, __eof))
  _M_gcount = 1;
       else
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __cb = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
  {
    _M_gcount = 1;
    __c = traits_type::to_char_type(__cb);
  }
       else
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c = __sb->sgetc();

       while (_M_gcount + 1 < __n
       && !traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim))
  {
    *__s++ = traits_type::to_char_type(__c);
    ++_M_gcount;
    __c = __sb->snextc();
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __this_sb = this->rdbuf();
       int_type __c = __this_sb->sgetc();
       char_type __c2 = traits_type::to_char_type(__c);

       while (!traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim)
       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  {
    ++_M_gcount;
    __c = __this_sb->snextc();
    __c2 = traits_type::to_char_type(__c);
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
          try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c = __sb->sgetc();

       while (_M_gcount + 1 < __n
       && !traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim))
  {
    streamsize __size = std::min(streamsize(__sb->egptr()
         - __sb->gptr()),
            __n - _M_gcount - 1);
    if (__size > 1)
      {
        const char_type* __p = traits_type::find(__sb->gptr(),
              __size,
              __delim);
        if (__p)
   __size = __p - __sb->gptr();
        traits_type::copy(__s, __sb->gptr(), __size);
        __s += __size;
        __sb->gbump(__size);
        _M_gcount += __size;
        __c = __sb->sgetc();
      }
    else
      {
        *__s++ = traits_type::to_char_type(__c);
        ++_M_gcount;
        __c = __sb->snextc();
      }
  }

       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
       else if (traits_type::eq_int_type(__c, __idelim))
  {
    ++_M_gcount;
    __sb->sbumpc();
  }
       else
  __err |= ios_base::failbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c;

       if (__n != numeric_limits<streamsize>::max())
  --__n;
       while (_M_gcount <= __n
       && !traits_type::eq_int_type(__c = __sb->sbumpc(), __eof))
  {
    ++_M_gcount;
    if (traits_type::eq_int_type(__c, __delim))
      break;
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {

       const streamsize __num = this->rdbuf()->in_avail();
       if (__num > 0)
  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
       else if (__num == -1)
  __err |= ios_base::eofbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sungetc(), __eof))
  __err |= ios_base::badbit;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {


      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (!this->fail())
     {

       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
            ios_base::in);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {


      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      try
 {
   if (!this->fail())
     {

       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
            ios_base::in);


       if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;
     }
 }
      catch(...)
 { this->_M_setstate(ios_base::badbit); }
      if (__err)
 this->setstate(__err);
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __int_type __cb = __in.rdbuf()->sbumpc();
       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
  __c = _Traits::to_char_type(__cb);
       else
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename _Traits::int_type int_type;
      typedef _CharT char_type;
      typedef ctype<_CharT> __ctype_type;

      streamsize __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __num = __in.width();
       if (__num <= 0)
  __num = numeric_limits<streamsize>::max();

       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

       const int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       int_type __c = __sb->sgetc();

       while (__extracted < __num - 1
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    *__s++ = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;



       *__s = char_type();
       __in.width(0);
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT,_Traits>&
    ws(basic_istream<_CharT,_Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename __istream_type::int_type __int_type;

      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
      const __int_type __eof = _Traits::eof();
      __streambuf_type* __sb = __in.rdbuf();
      __int_type __c = __sb->sgetc();

      while (!_Traits::eq_int_type(__c, __eof)
      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
 __c = __sb->snextc();

       if (_Traits::eq_int_type(__c, __eof))
  __in.setstate(ios_base::eofbit);
      return __in;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
       __in.width(0);
     }
   catch(...)
     {



       __in._M_setstate(ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __sb->sbumpc();
  }
       else
  __err |= ios_base::failbit;
     }
   catch(...)
     {



       __in._M_setstate(ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<class _CharT, class _Traits, class _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT,_Traits,_Alloc>& __str)
    { return getline(__in, __str, __in.widen('\n')); }





  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, char*);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);
  extern template istream& operator>>(istream&, unsigned char*);
  extern template istream& operator>>(istream&, signed char*);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template wistream& operator>>(wistream&, wchar_t*);

  extern template class basic_iostream<wchar_t>;


}
# 772 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/istream" 2 3
# 47 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 2 3

namespace std
{
# 63 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/iostream" 3
  extern istream cin;
  extern ostream cout;
  extern ostream cerr;
  extern ostream clog;


  extern wistream wcin;
  extern wostream wcout;
  extern wostream wcerr;
  extern wostream wclog;




  static ios_base::Init __ioinit;
}
# 43 "../../../src/systemc/utils/sc_iostream.h" 2
# 51 "../../../src/systemc/utils/sc_iostream.h"
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3




namespace std
{
# 62 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_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_string<char_type, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;


    protected:





      ios_base::openmode _M_mode;







      __string_type _M_string;

    public:
# 112 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 125 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
      { _M_stringbuf_init(__mode); }
# 140 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      __string_type
      str() const
      {
 if (this->pptr())
   {

     if (this->pptr() > this->egptr())
       return __string_type(this->pbase(), this->pptr());
     else
        return __string_type(this->pbase(), this->egptr());
   }
 else
   return _M_string;
      }
# 162 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      void
      str(const __string_type& __s)
      {

 _M_string.assign(__s.data(), __s.size());
 _M_stringbuf_init(this->_M_mode);
      }

    protected:






      void
      _M_stringbuf_init(ios_base::openmode __mode)
      {
 this->_M_mode = __mode;

 __size_type __len = 0;
 if (this->_M_mode & (ios_base::ate | ios_base::app))
   __len = _M_string.size();
 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
      }


      virtual int_type
      underflow();


      virtual int_type
      pbackfail(int_type __c = traits_type::eof());


      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 211 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n)
      {
 if (__s && __n >= 0)
   {






     _M_string = __string_type(__s, __n);


     _M_sync(__s, 0, 0);
   }
 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 __sp,
       ios_base::openmode __mode = ios_base::in | ios_base::out);
# 251 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      void
      _M_sync(char_type* __base, __size_type __i, __size_type __o)
      {
 const bool __testin = this->_M_mode & ios_base::in;
 const bool __testout = this->_M_mode & ios_base::out;
 const __size_type __len = _M_string.size();

 if (__testin)
   this->setg(__base, __base + __i, __base + __len);
 if (__testout)
   {
     this->setp(__base, __base + _M_string.capacity());
     this->pbump(__o);




     if (!__testin)
       this->setg(__base + __len, __base + __len, __base + __len);
   }
      }



      void
      _M_update_egptr()
      {
 const bool __testin = this->_M_mode & ios_base::in;

 if (this->pptr() && this->pptr() > this->egptr())
   if (__testin)
     this->setg(this->eback(), this->gptr(), this->pptr());
   else
     this->setg(this->pptr(), this->pptr(), this->pptr());
      }
    };
# 298 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_istringstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:





      __stringbuf_type _M_stringbuf;

    public:
# 341 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 361 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_istringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
      { this->init(&_M_stringbuf); }







      ~basic_istringstream()
      { }
# 383 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 416 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:





      __stringbuf_type _M_stringbuf;

    public:
# 459 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 479 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_ostringstream(const __string_type& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
      { this->init(&_M_stringbuf); }







      ~basic_ostringstream()
      { }
# 501 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
# 534 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:





      __stringbuf_type _M_stringbuf;

    public:
# 575 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 593 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      explicit
      basic_stringstream(const __string_type& __str,
    ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__str, __m)
      { this->init(&_M_stringbuf); }







      ~basic_stringstream()
      { }
# 615 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const
      { return _M_stringbuf.str(); }







      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }
    };
}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/sstream.tcc" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/sstream.tcc" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/sstream.tcc" 3

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 1 3
# 41 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/sstream.tcc" 2 3

namespace std
{
  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);

      if (this->eback() < this->gptr())
 {
   const bool __testeq = traits_type::eq(traits_type::to_char_type(__c),
      this->gptr()[-1]);
   this->gbump(-1);



   if (!__testeof && __testeq)
     __ret = __c;
   else if (__testeof)
     __ret = traits_type::not_eof(__c);
   else
     {
       *this->gptr() = traits_type::to_char_type(__c);
       __ret = __c;
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();
      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      if (!__testput)
 {






   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp;
   __tmp.reserve(__len);
   __tmp.assign(_M_string.data(), this->epptr() - this->pbase());
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      return this->sputc(traits_type::to_char_type(__c));
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin)
 {

   _M_update_egptr();

   if (this->gptr() < this->egptr())
     __ret = traits_type::to_int_type(*this->gptr());
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
      const bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);



      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !__off) && (__testin || __testout || __testboth))
 {
   _M_update_egptr();

   off_type __newoffi = 0;
   off_type __newoffo = 0;
   if (__way == ios_base::cur)
     {
       __newoffi = this->gptr() - __beg;
       __newoffo = this->pptr() - __beg;
     }
   else if (__way == ios_base::end)
     __newoffo = __newoffi = this->egptr() - __beg;

   if ((__testin || __testboth)
       && __newoffi + __off >= 0
       && this->egptr() - __beg >= __newoffi + __off)
     {
       this->gbump((__beg + __newoffi + __off) - this->gptr());
       __ret = pos_type(__newoffi);
     }
   if ((__testout || __testboth)
       && __newoffo + __off >= 0
       && this->egptr() - __beg >= __newoffo + __off)
     {
       this->pbump((__beg + __newoffo + __off) - this->pptr());
       __ret = pos_type(__newoffo);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekpos(pos_type __sp, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;

      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if (__beg)
 {
   _M_update_egptr();

   off_type __pos(__sp);
   const bool __testpos = 0 <= __pos
                          && __pos <= this->egptr() - __beg;
   if ((__testin || __testout) && __testpos)
     {
       if (__testin)
  this->gbump((__beg + __pos) - this->gptr());
       if (__testout)
                this->pbump((__beg + __pos) - this->pptr());
       __ret = __sp;
     }
 }
      return __ret;
    }





  extern template class basic_stringbuf<char>;
  extern template class basic_istringstream<char>;
  extern template class basic_ostringstream<char>;
  extern template class basic_stringstream<char>;


  extern template class basic_stringbuf<wchar_t>;
  extern template class basic_istringstream<wchar_t>;
  extern template class basic_ostringstream<wchar_t>;
  extern template class basic_stringstream<wchar_t>;


}
# 641 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/sstream" 2 3
# 52 "../../../src/systemc/utils/sc_iostream.h" 2


using std::ios;
using std::streambuf;
using std::streampos;
using std::streamsize;
using std::iostream;
using std::istream;
using std::ostream;
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::flush;
using std::dec;
using std::hex;
using std::oct;

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 1 3
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
       
# 44 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3





# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/basic_file.h" 1 3
# 42 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/basic_file.h" 3
       
# 43 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/i386-redhat-linux/bits/basic_file.h" 3




namespace std
{

  template<typename _CharT>
    class __basic_file;


  template<>
    class __basic_file<char>
    {

      __c_file* _M_cfile;


      bool _M_cfile_created;

    public:
      __basic_file(__c_lock* __lock = 0);

      __basic_file*
      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);

      __basic_file*
      sys_open(__c_file* __file, ios_base::openmode);

      __basic_file*
      sys_open(int __fd, ios_base::openmode __mode);

      __basic_file*
      close();

      bool
      is_open() const;

      int
      fd();

      __c_file*
      file();

      ~__basic_file();

      streamsize
      xsputn(const char* __s, streamsize __n);

      streamsize
      xsputn_2(const char* __s1, streamsize __n1,
        const char* __s2, streamsize __n2);

      streamsize
      xsgetn(char* __s, streamsize __n);

      streamoff
      seekoff(streamoff __off, ios_base::seekdir __way);

      int
      sync();

      streamsize
      showmanyc();
    };
}
# 50 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 2 3


namespace std
{
# 68 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
  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> __file_type;
      typedef typename traits_type::state_type __state_type;
      typedef codecvt<char_type, char, __state_type> __codecvt_type;


      friend class ios_base;

    protected:







      __c_lock _M_lock;







      __file_type _M_file;






      ios_base::openmode _M_mode;







      __state_type _M_state_beg;
# 135 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __state_type _M_state_cur;
# 144 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __state_type _M_state_last;






      char_type* _M_buf;
# 160 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      size_t _M_buf_size;







      bool _M_buf_allocated;
# 179 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      bool _M_reading;
      bool _M_writing;
# 190 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      char_type _M_pback;
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;



      const __codecvt_type* _M_codecvt;
# 206 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      char* _M_ext_buf;






      streamsize _M_ext_buf_size;
# 222 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      const char* _M_ext_next;
      char* _M_ext_end;
# 232 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      _M_create_pback()
      {
 if (!_M_pback_init)
   {
     _M_pback_cur_save = this->gptr();
     _M_pback_end_save = this->egptr();
     this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
     _M_pback_init = true;
   }
      }
# 251 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      _M_destroy_pback() throw()
      {
 if (_M_pback_init)
   {

     _M_pback_cur_save += this->gptr() != this->eback();
     this->setg(this->_M_buf, _M_pback_cur_save, _M_pback_end_save);
     _M_pback_init = false;
   }
      }

    public:







      basic_filebuf();




      virtual
      ~basic_filebuf()
      { this->close(); }





      bool
      is_open() const throw() { return _M_file.is_open(); }
# 300 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
# 314 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __filebuf_type*
      close() throw();

    protected:





      void
      _M_allocate_internal_buffer();






      void
      _M_destroy_internal_buffer() throw();



      virtual streamsize
      showmanyc();







      virtual int_type
      underflow();


      virtual int_type
      pbackfail(int_type __c = _Traits::eof());
# 364 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      virtual int_type
      overflow(int_type __c = _Traits::eof());
# 374 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      bool
      _M_convert_to_external(char_type*, streamsize);
# 389 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n);


      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);







      pos_type
      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);


      virtual int
      sync();


      virtual void
      imbue(const locale& __loc);


      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);


      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);







      bool
      _M_terminate_output();
# 450 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      _M_set_buffer(streamsize __off)
      {
  const bool __testin = this->_M_mode & ios_base::in;
  const bool __testout = this->_M_mode & ios_base::out;

 if (__testin && __off > 0)
   this->setg(this->_M_buf, this->_M_buf, this->_M_buf + __off);
 else
   this->setg(this->_M_buf, this->_M_buf, this->_M_buf);

 if (__testout && __off == 0 && this->_M_buf_size > 1 )
   this->setp(this->_M_buf, this->_M_buf + this->_M_buf_size - 1);
 else
   this->setp(__null, __null);
      }
    };
# 477 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
  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;

    private:





      __filebuf_type _M_filebuf;

    public:
# 509 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      basic_ifstream() : __istream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 522 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      explicit
      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }







      ~basic_ifstream()
      { }
# 546 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open() { return _M_filebuf.is_open(); }
# 568 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      open(const char* __s, ios_base::openmode __mode = ios_base::in)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::in))
   this->setstate(ios_base::failbit);
      }







      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 599 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
  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;

    private:





      __filebuf_type _M_filebuf;

    public:
# 631 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      basic_ofstream(): __ostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 645 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      explicit
      basic_ofstream(const char* __s,
       ios_base::openmode __mode = ios_base::out|ios_base::trunc)
      : __ostream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }







      ~basic_ofstream()
      { }
# 670 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open() { return _M_filebuf.is_open(); }
# 692 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      open(const char* __s,
    ios_base::openmode __mode = ios_base::out | ios_base::trunc)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::out))
   this->setstate(ios_base::failbit);
      }







      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 724 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
  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;

    private:





      __filebuf_type _M_filebuf;

    public:
# 757 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      basic_fstream()
      : __iostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 769 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      explicit
      basic_fstream(const char* __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(__null), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }







      ~basic_fstream()
      { }
# 794 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open() { return _M_filebuf.is_open(); }
# 816 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 3
      void
      open(const char* __s,
    ios_base::openmode __mode = ios_base::in | ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode))
   this->setstate(ios_base::failbit);
      }







      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
}


# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/fstream.tcc" 1 3
# 38 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/fstream.tcc" 3
       
# 39 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/fstream.tcc" 3

namespace std
{
  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_allocate_internal_buffer()
    {


      if (!_M_buf_allocated && !this->_M_buf)
 {
   this->_M_buf = new char_type[this->_M_buf_size];
   _M_buf_allocated = true;
 }
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_destroy_internal_buffer() throw()
    {
      if (_M_buf_allocated)
 {
   delete [] this->_M_buf;
   this->_M_buf = __null;
   _M_buf_allocated = false;
 }
      delete [] _M_ext_buf;
      _M_ext_buf = __null;
      _M_ext_buf_size = 0;
      _M_ext_next = __null;
      _M_ext_end = __null;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
    _M_state_last(), _M_buf(__null), _M_buf_size(8192),
    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
    _M_ext_end(0)
    {
      if (has_facet<__codecvt_type>(this->_M_buf_locale))
 _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    open(const char* __s, ios_base::openmode __mode)
    {
      __filebuf_type *__ret = __null;
      if (!this->is_open())
 {
   _M_file.open(__s, __mode);
   if (this->is_open())
     {
       _M_allocate_internal_buffer();
       this->_M_mode = __mode;


       _M_reading = false;
       _M_writing = false;
       _M_set_buffer(-1);


       _M_state_last = _M_state_cur = _M_state_beg;


       if ((__mode & ios_base::ate)
    && this->seekoff(0, ios_base::end, __mode)
    == pos_type(off_type(-1)))
  this->close();
       else
  __ret = this;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    close() throw()
    {
      __filebuf_type* __ret = __null;
      if (this->is_open())
 {
   bool __testfail = false;
   try
     {
       if (!_M_terminate_output())
  __testfail = true;
     }
   catch(...)
     { __testfail = true; }


   this->_M_mode = ios_base::openmode(0);
   this->_M_pback_init = false;
   _M_destroy_internal_buffer();
   _M_reading = false;
   _M_writing = false;
   _M_set_buffer(-1);
   _M_state_last = _M_state_cur = _M_state_beg;

   if (!_M_file.close())
     __testfail = true;

   if (!__testfail)
     __ret = this;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    showmanyc()
    {
      streamsize __ret = -1;
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin && this->is_open())
 {


   __ret = this->egptr() - this->gptr();
   if (__check_facet(_M_codecvt).encoding() >= 0)
     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin && !_M_writing)
 {



   _M_destroy_pback();

   if (this->gptr() < this->egptr())
     return traits_type::to_int_type(*this->gptr());


   const size_t __buflen = this->_M_buf_size > 1
                           ? this->_M_buf_size - 1 : 1;


   bool __got_eof = false;

   streamsize __ilen = 0;
   codecvt_base::result __r = codecvt_base::ok;
   if (__check_facet(_M_codecvt).always_noconv())
     {
       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
          __buflen);
       if (__ilen == 0)
  __got_eof = true;
     }
   else
     {


       const int __enc = _M_codecvt->encoding();
       streamsize __blen;
       streamsize __rlen;
       if (__enc > 0)
  __blen = __rlen = __buflen * __enc;
       else
  {
    __blen = __buflen + _M_codecvt->max_length() - 1;
    __rlen = __buflen;
  }
       const streamsize __remainder = _M_ext_end - _M_ext_next;
       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;



       if (_M_reading && this->egptr() == this->eback() && __remainder)
  __rlen = 0;



       if (_M_ext_buf_size < __blen)
  {
    char* __buf = new char[__blen];
    if (__remainder)
      std::memcpy(__buf, _M_ext_next, __remainder);

    delete [] _M_ext_buf;
    _M_ext_buf = __buf;
    _M_ext_buf_size = __blen;
  }
       else if (__remainder)
  std::memmove(_M_ext_buf, _M_ext_next, __remainder);

       _M_ext_next = _M_ext_buf;
       _M_ext_end = _M_ext_buf + __remainder;
       _M_state_last = _M_state_cur;

       do
  {
    if (__rlen > 0)
      {



        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
   {
     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid"));


   }
        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
        if (__elen == 0)
   __got_eof = true;
        else if (__elen == -1)
   break;
        _M_ext_end += __elen;
      }

    char_type* __iend;
    __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
           _M_ext_end, _M_ext_next, this->eback(),
           this->eback() + __buflen, __iend);
    if (__r == codecvt_base::noconv)
      {
        size_t __avail = _M_ext_end - _M_ext_buf;
        __ilen = std::min(__avail, __buflen);
        traits_type::copy(this->eback(),
     reinterpret_cast<char_type*>(_M_ext_buf), __ilen);
        _M_ext_next = _M_ext_buf + __ilen;
      }
    else
      __ilen = __iend - this->eback();




    if (__r == codecvt_base::error)
      break;

    __rlen = 1;
  }
       while (__ilen == 0 && !__got_eof);
     }

   if (__ilen > 0)
     {
       _M_set_buffer(__ilen);
       _M_reading = true;
       __ret = traits_type::to_int_type(*this->gptr());
     }
   else if (__got_eof)
     {



       _M_set_buffer(-1);
       _M_reading = false;


       if (__r == codecvt_base::partial)
  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file"));

     }
   else if (__r == codecvt_base::error)
     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file"));

   else
     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file"));

 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    pbackfail(int_type __i)
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin && !_M_writing)
 {


   const bool __testpb = this->_M_pback_init;
   const bool __testeof = traits_type::eq_int_type(__i, __ret);
   int_type __tmp;
   if (this->eback() < this->gptr())
     {
       this->gbump(-1);
       __tmp = traits_type::to_int_type(*this->gptr());
     }
   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
     {
       __tmp = this->underflow();
       if (traits_type::eq_int_type(__tmp, __ret))
  return __ret;
     }
   else
     {





       return __ret;
     }



   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
     __ret = __i;
   else if (__testeof)
     __ret = traits_type::not_eof(__i);
   else if (!__testpb)
     {
       _M_create_pback();
       _M_reading = true;
       *this->gptr() = traits_type::to_char_type(__i);
       __ret = __i;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    overflow(int_type __c)
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);
      const bool __testout = this->_M_mode & ios_base::out;
      if (__testout && !_M_reading)
 {
   if (this->pbase() < this->pptr())
     {

       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }



       if (_M_convert_to_external(this->pbase(),
      this->pptr() - this->pbase())
    && (!__testeof || !_M_file.sync()))
  {
    _M_set_buffer(0);
    __ret = traits_type::not_eof(__c);
  }
     }
   else if (this->_M_buf_size > 1)
     {



       _M_set_buffer(0);
       _M_writing = true;
       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }
       __ret = traits_type::not_eof(__c);
     }
   else
     {

       char_type __conv = traits_type::to_char_type(__c);
       if (__testeof || _M_convert_to_external(&__conv, 1))
  {
    _M_writing = true;
    __ret = traits_type::not_eof(__c);
  }
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
    {

      streamsize __elen;
      streamsize __plen;
      if (__check_facet(_M_codecvt).always_noconv())
 {
   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
   __plen = __ilen;
 }
      else
 {


   streamsize __blen = __ilen * _M_codecvt->max_length();
   char* __buf = static_cast<char*>(__builtin_alloca(__blen));

   char* __bend;
   const char_type* __iend;
   codecvt_base::result __r;
   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
    __iend, __buf, __buf + __blen, __bend);

   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
     __blen = __bend - __buf;
   else if (__r == codecvt_base::noconv)
     {

       __buf = reinterpret_cast<char*>(__ibuf);
       __blen = __ilen;
     }
   else
     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));


   __elen = _M_file.xsputn(__buf, __blen);
   __plen = __blen;


   if (__r == codecvt_base::partial && __elen == __plen)
     {
       const char_type* __iresume = __iend;
       streamsize __rlen = this->pptr() - __iend;
       __r = _M_codecvt->out(_M_state_cur, __iresume,
        __iresume + __rlen, __iend, __buf,
        __buf + __blen, __bend);
       if (__r != codecvt_base::error)
  {
    __rlen = __bend - __buf;
    __elen = _M_file.xsputn(__buf, __rlen);
    __plen = __rlen;
  }
       else
  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));

     }
 }
      return __elen == __plen;
    }

   template<typename _CharT, typename _Traits>
     streamsize
     basic_filebuf<_CharT, _Traits>::
     xsgetn(_CharT* __s, streamsize __n)
     {

       streamsize __ret = 0;
       if (this->_M_pback_init)
  {
    if (__n > 0 && this->gptr() == this->eback())
      {
        *__s++ = *this->gptr();
        this->gbump(1);
        __ret = 1;
        --__n;
      }
    _M_destroy_pback();
  }




       const bool __testin = this->_M_mode & ios_base::in;
       const streamsize __buflen = this->_M_buf_size > 1 ? this->_M_buf_size - 1
                                                  : 1;
       if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
    && __testin && !_M_writing)
  {

    const streamsize __avail = this->egptr() - this->gptr();
    if (__avail != 0)
      {
        if (__avail == 1)
   *__s = *this->gptr();
        else
   traits_type::copy(__s, this->gptr(), __avail);
        __s += __avail;
        this->gbump(__avail);
        __ret += __avail;
        __n -= __avail;
      }

    const streamsize __len = _M_file.xsgetn(reinterpret_cast<char*>(__s),
         __n);
    if (__len == -1)
      __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file"));

    __ret += __len;
    if (__len == __n)
      {
        _M_set_buffer(0);
        _M_reading = true;
      }
    else if (__len == 0)
      {



        _M_set_buffer(-1);
        _M_reading = false;
      }
  }
       else
  __ret += __streambuf_type::xsgetn(__s, __n);

       return __ret;
     }

   template<typename _CharT, typename _Traits>
     streamsize
     basic_filebuf<_CharT, _Traits>::
     xsputn(const _CharT* __s, streamsize __n)
     {



       streamsize __ret = 0;
       const bool __testout = this->_M_mode & ios_base::out;
       if (__check_facet(_M_codecvt).always_noconv()
    && __testout && !_M_reading)
 {

   const streamsize __chunk = 1ul << 10;
   streamsize __bufavail = this->epptr() - this->pptr();


   if (!_M_writing && this->_M_buf_size > 1)
     __bufavail = this->_M_buf_size - 1;

   const streamsize __limit = std::min(__chunk, __bufavail);
   if (__n >= __limit)
     {
       const streamsize __buffill = this->pptr() - this->pbase();
       const char* __buf = reinterpret_cast<const char*>(this->pbase());
       __ret = _M_file.xsputn_2(__buf, __buffill,
           reinterpret_cast<const char*>(__s),
           __n);
       if (__ret == __buffill + __n)
  {
    _M_set_buffer(0);
    _M_writing = true;
  }
       if (__ret > __buffill)
  __ret -= __buffill;
       else
  __ret = 0;
     }
   else
     __ret = __streambuf_type::xsputn(__s, __n);
 }
       else
  __ret = __streambuf_type::xsputn(__s, __n);
       return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
    basic_filebuf<_CharT, _Traits>::
    setbuf(char_type* __s, streamsize __n)
    {
      if (!this->is_open())
 if (__s == 0 && __n == 0)
   this->_M_buf_size = 1;
 else if (__s && __n > 0)
   {
# 630 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/bits/fstream.tcc" 3
     this->_M_buf = __s;
     this->_M_buf_size = __n;
   }
      return this;
    }




  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
    {
      int __width = 0;
      if (_M_codecvt)
 __width = _M_codecvt->encoding();
      if (__width < 0)
 __width = 0;

      pos_type __ret = pos_type(off_type(-1));
      const bool __testfail = __off != 0 && __width <= 0;
      if (this->is_open() && !__testfail)
 {

   _M_destroy_pback();






   __state_type __state = _M_state_beg;
   off_type __computed_off = __off * __width;
   if (_M_reading && __way == ios_base::cur)
     {
       if (_M_codecvt->always_noconv())
  __computed_off += this->gptr() - this->egptr();
       else
  {



    const int __gptr_off =
      _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next,
           this->gptr() - this->eback());
    __computed_off += _M_ext_buf + __gptr_off - _M_ext_end;



    __state = _M_state_last;
  }
     }
   __ret = _M_seek(__computed_off, __way, __state);
 }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekpos(pos_type __pos, ios_base::openmode)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (this->is_open())
 {

   _M_destroy_pback();
   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (_M_terminate_output())
 {

   __ret = pos_type(_M_file.seekoff(__off, __way));
   _M_reading = false;
   _M_writing = false;
   _M_ext_next = _M_ext_end = _M_ext_buf;
   _M_set_buffer(-1);
   _M_state_cur = __state;
   __ret.state(_M_state_cur);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_terminate_output()
    {

      bool __testvalid = true;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __testvalid = false;
 }


      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
   && __testvalid)
 {



   const size_t __blen = 128;
   char __buf[__blen];
   codecvt_base::result __r;
   streamsize __ilen = 0;

   do
     {
       char* __next;
       __r = _M_codecvt->unshift(_M_state_cur, __buf,
     __buf + __blen, __next);
       if (__r == codecvt_base::error)
  __testvalid = false;
       else if (__r == codecvt_base::ok ||
         __r == codecvt_base::partial)
  {
    __ilen = __next - __buf;
    if (__ilen > 0)
      {
        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
        if (__elen != __ilen)
   __testvalid = false;
      }
  }
     }
   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);

   if (__testvalid)
     {




       const int_type __tmp = this->overflow();
       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
  __testvalid = false;
     }
 }
      return __testvalid;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_filebuf<_CharT, _Traits>::
    sync()
    {



      int __ret = 0;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __ret = -1;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    imbue(const locale& __loc)
    {
      bool __testvalid = true;

      const __codecvt_type* _M_codecvt_tmp = 0;
      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
 _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);

      if (this->is_open())
 {

   if ((_M_reading || _M_writing)
       && __check_facet(_M_codecvt).encoding() == -1)
     __testvalid = false;
   else
     {
       if (_M_reading)
  {
    if (__check_facet(_M_codecvt).always_noconv())
      {
        if (_M_codecvt_tmp
     && !__check_facet(_M_codecvt_tmp).always_noconv())
   __testvalid = this->seekoff(0, ios_base::cur, this->_M_mode)
                 != pos_type(off_type(-1));
      }
    else
      {

        _M_ext_next = _M_ext_buf
   + _M_codecvt->length(_M_state_last, _M_ext_buf, _M_ext_next,
          this->gptr() - this->eback());
        const streamsize __remainder = _M_ext_end - _M_ext_next;
        if (__remainder)
   std::memmove(_M_ext_buf, _M_ext_next, __remainder);

        _M_ext_next = _M_ext_buf;
        _M_ext_end = _M_ext_buf + __remainder;
        _M_set_buffer(-1);
        _M_state_last = _M_state_cur = _M_state_beg;
      }
  }
       else if (_M_writing && (__testvalid = _M_terminate_output()))
  _M_set_buffer(-1);
     }
 }

      if (__testvalid)
 _M_codecvt = _M_codecvt_tmp;
      else
 _M_codecvt = 0;
    }





  extern template class basic_filebuf<char>;
  extern template class basic_ifstream<char>;
  extern template class basic_ofstream<char>;
  extern template class basic_fstream<char>;


  extern template class basic_filebuf<wchar_t>;
  extern template class basic_ifstream<wchar_t>;
  extern template class basic_ofstream<wchar_t>;
  extern template class basic_fstream<wchar_t>;


}
# 841 "/usr/lib/gcc/i386-redhat-linux/3.4.2/../../../../include/c++/3.4.2/fstream" 2 3
# 71 "../../../src/systemc/utils/sc_iostream.h" 2
using std::fstream;
using std::ifstream;
using std::ofstream;


using std::size_t;


using std::memchr;
using std::memcmp;
using std::memcpy;
using std::memmove;
using std::memset;
using std::strcat;
using std::strncat;
using std::strchr;
using std::strrchr;
using std::strcmp;
using std::strncmp;
using std::strcpy;
using std::strncpy;
using std::strcspn;
using std::strspn;
using std::strlen;
using std::strpbrk;
using std::strstr;
using std::strtok;
# 42 "../../../src/systemc/kernel/sc_process.h" 2
# 1 "../../../src/systemc/kernel/sc_constants.h" 1
# 49 "../../../src/systemc/kernel/sc_constants.h"
const int SC_DEFAULT_STACK_SIZE = 0x10000;
const int SC_MAX_WATCH_LEVEL = 16;
# 43 "../../../src/systemc/kernel/sc_process.h" 2






typedef class sc_cthread_process* sc_cthread_handle;
typedef class sc_method_process* sc_method_handle;
typedef class sc_thread_process* sc_thread_handle;

class sc_process_b;
class sc_process_host;
# 94 "../../../src/systemc/kernel/sc_process.h"
    typedef void (sc_process_host::*SC_ENTRY_FUNC)();
# 114 "../../../src/systemc/kernel/sc_process.h"
extern void sc_set_stack_size( sc_thread_handle, size_t );
# 60 "../../../src/systemc/kernel/sc_simcontext.h" 2
# 1 "../../../src/systemc/kernel/sc_time.h" 1
# 40 "../../../src/systemc/kernel/sc_time.h"
# 1 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 1
# 41 "../../../src/systemc/datatypes/int/sc_nbdefs.h"
# 1 "../../../src/systemc/kernel/sc_cmnhdr.h" 1
# 42 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 2

# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 1 3 4
# 44 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 2

# 1 "../../../src/systemc/utils/sc_iostream.h" 1
# 46 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 2
# 1 "../../../src/systemc/kernel/sc_constants.h" 1
# 47 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 2
# 1 "../../../src/systemc/utils/sc_string.h" 1
# 41 "../../../src/systemc/utils/sc_string.h"
# 1 "../../../src/systemc/utils/sc_iostream.h" 1
# 42 "../../../src/systemc/utils/sc_string.h" 2
# 1 "../../../src/systemc/utils/sc_report.h" 1
# 50 "../../../src/systemc/utils/sc_report.h"
enum sc_severity {
    SC_INFO = 0,
    SC_WARNING,
    SC_ERROR,
    SC_FATAL,
    SC_MAX_SEVERITY
};

typedef unsigned sc_actions;







enum {
    SC_UNSPECIFIED = 0x0000,
    SC_DO_NOTHING = 0x0001,
    SC_THROW = 0x0002,
    SC_LOG = 0x0004,
    SC_DISPLAY = 0x0008,
    SC_CACHE_REPORT = 0x0010,
    SC_INTERRUPT = 0x0020,
    SC_STOP = 0x0040,
    SC_ABORT = 0x0080
};

class sc_object;
class sc_time;
struct sc_msg_def;







class sc_report
{
public:

    sc_report(const sc_report&);

    sc_report & operator=(const sc_report&);

    virtual ~sc_report();

    const char * get_msg_type() const;

    const char * get_msg() const
 { return msg; }

    sc_severity get_severity() const
 { return severity; }

    const char * get_file_name() const
 { return file; }

    int get_line_number() const
 { return line; }

    const sc_time & get_time() const
 { return *timestamp; }

    const char* get_process_name() const;

protected:

    friend class sc_report_handler;

    sc_report(sc_severity,
       const sc_msg_def*,
       const char* msg,
       const char* file,
       int line);

    sc_severity severity;
    const sc_msg_def* md;
    char* msg;
    char* file;
    int line;
    sc_time* timestamp;
    sc_object* process;

public:

    static void register_id(int id, const char* msg);
    static const char* get_message(int id);
    static bool is_suppressed(int id);

    static void suppress_id(int id, bool);
    static void suppress_infos(bool);
    static void suppress_warnings(bool);
    static void make_warnings_errors(bool);

    int get_id() const;
};
# 193 "../../../src/systemc/utils/sc_report.h"
extern const char SC_ID_UNKNOWN_ERROR_[];
extern const char SC_ID_WITHOUT_MESSAGE_[];
extern const char SC_ID_NOT_IMPLEMENTED_[];
extern const char SC_ID_INTERNAL_ERROR_[];
extern const char SC_ID_ASSERTION_FAILED_[];
extern const char SC_ID_OUT_OF_BOUNDS_[];


extern const char SC_ID_REGISTER_ID_FAILED_[];

# 1 "../../../src/systemc/utils/sc_report_handler.h" 1
# 46 "../../../src/systemc/utils/sc_report_handler.h"
struct sc_msg_def
{
    const char* msg_type;
    sc_actions actions;
    sc_actions sev_actions[SC_MAX_SEVERITY];
    unsigned limit;
    unsigned sev_limit[SC_MAX_SEVERITY];
    unsigned limit_mask;
    unsigned call_count;
    unsigned sev_call_count[SC_MAX_SEVERITY];
    char* msg_type_data;

    int id;
};

typedef void (* sc_report_handler_proc)(const sc_report&, const sc_actions &);
class sc_report;

class sc_report_handler
{
public:
    static void report(sc_severity,
         const char* msg_type,
         const char* msg,
         const char* file,
         int line);

    static sc_actions set_actions(sc_severity,
      sc_actions = SC_UNSPECIFIED);

    static sc_actions set_actions(const char * msg_type,
      sc_actions = SC_UNSPECIFIED);

    static sc_actions set_actions(const char * msg_type,
      sc_severity,
      sc_actions = SC_UNSPECIFIED);

    static int stop_after(sc_severity, int limit = -1);
    static int stop_after(const char* msg_type, int limit = -1);
    static int stop_after(const char* msg_type, sc_severity, int limit = -1);

    static sc_actions suppress(sc_actions);
    static sc_actions suppress();
    static sc_actions force(sc_actions);
    static sc_actions force();

    static void initialize();
    static void release();

    static void set_handler(sc_report_handler_proc);

    static void default_handler(const sc_report&, const sc_actions&);

    static sc_actions get_new_action_id();

    static sc_report* get_cached_report();
    static void clear_cached_report();




    static bool set_log_file_name(const char* filename);
    static const char* get_log_file_name();

public:

    struct msg_def_items
    {
 sc_msg_def* md;
 int count;
 bool allocated;
 msg_def_items* next;
    };

    static void add_static_msg_types(msg_def_items *);
    static sc_msg_def* add_msg_type(const char * msg_type);

protected:

    static void cache_report(const sc_report&);
    static sc_actions execute(sc_msg_def*, sc_severity);

    static sc_actions suppress_mask;
    static sc_actions force_mask;
    static sc_actions sev_actions[SC_MAX_SEVERITY];
    static unsigned sev_limit[SC_MAX_SEVERITY];
    static unsigned sev_call_count[SC_MAX_SEVERITY];
    static sc_report* last_global_report;
    static sc_actions available_actions;
    static char* log_file_name;

    static msg_def_items* messages;
    static msg_def_items msg_terminator;

    static sc_report_handler_proc handler;

    static sc_msg_def* mdlookup(const char* msg_type);

private:

    friend class sc_report;
    static sc_msg_def* mdlookup(int id);

public:

    static void report(sc_severity,
         int id,
         const char* add_msg,
         const char* file,
         int line);

};
# 204 "../../../src/systemc/utils/sc_report.h" 2
# 43 "../../../src/systemc/utils/sc_string.h" 2



class sc_string;


class sc_string_rep;
# 58 "../../../src/systemc/utils/sc_string.h"
enum sc_numrep
{
    SC_NOBASE = 0,
    SC_BIN = 2,
    SC_OCT = 8,
    SC_DEC = 10,
    SC_HEX = 16,
    SC_BIN_US,
    SC_BIN_SM,
    SC_OCT_US,
    SC_OCT_SM,
    SC_HEX_US,
    SC_HEX_SM,
    SC_CSD
};


const sc_string to_string( sc_numrep );
# 84 "../../../src/systemc/utils/sc_string.h"
class sc_string
{
    friend ostream& operator << ( ostream& os, const sc_string& a );
    friend istream& operator >> ( istream& is, sc_string& a );

public:



    explicit sc_string( int size = 16 );
    sc_string( const char* s );
    sc_string( const char* s, int n );
    sc_string( const sc_string& s );




    ~sc_string();




    sc_string& operator = ( const char* s );
    sc_string& operator = ( const sc_string& s );

    sc_string& operator += ( const char* s );
    sc_string& operator += ( char c );
    sc_string& operator += ( const sc_string& s );

    sc_string operator + ( const char* s ) const;
    sc_string operator + ( char c ) const;
    sc_string operator + ( const sc_string& s ) const;

    friend sc_string operator + ( const char* s, const sc_string& t );




    sc_string substr( int first, int last ) const;




    bool operator == ( const char* s ) const;
    bool operator != ( const char* s ) const;
    bool operator < ( const char* s ) const;
    bool operator <= ( const char* s ) const;
    bool operator > ( const char* s ) const;
    bool operator >= ( const char* s ) const;
    bool operator == ( const sc_string& s ) const;
    bool operator != ( const sc_string& s ) const;
    bool operator < ( const sc_string& s ) const;
    bool operator <= ( const sc_string& s ) const;
    bool operator > ( const sc_string& s ) const;
    bool operator >= ( const sc_string& s ) const;




    int length() const;




    const char* c_str() const;



    operator const char*() const;



    char operator[](int index) const;



    char& operator[](int index);


    static sc_string to_string(const char* format, ...);
# 174 "../../../src/systemc/utils/sc_string.h"
    template<class T> sc_string& fmt(const T& t)
 {

     int index;
     int len = length();
     sc_string temp(*this);
     do
     {
  index = temp.pos("%");
  if(index == length()-1)
      return *this;
  temp = substr(index+1,len-1);
     } while(temp[0] != '%');
     int f_len = (int)temp.fmt_length();
     temp = to_string(substr(0,index+f_len-1).c_str(),t);
     return (*this) = temp + substr(index+f_len,len);
 }
    sc_string& fmt(const sc_string& s);




    int pos(const sc_string& sub_string)const;



    sc_string& remove(unsigned index, unsigned length);



    sc_string& insert(const sc_string& sub_string, unsigned index);




    bool is_delimiter(const sc_string& str, unsigned index)const;



    bool contains(char c)const;



    sc_string uppercase()const;



    sc_string lowercase()const;



    static sc_string make_str(long n);
    void set( int index, char c );
    int cmp( const char* s ) const;
    int cmp( const sc_string& s ) const;


    void print( ostream& os = cout ) const;

private:

    sc_string( sc_string_rep* r );

    sc_string_rep* rep;

    void test(int position)const;
    unsigned fmt_length()const;
};




inline
ostream&
operator << ( ostream& os, sc_numrep numrep )
{
    os << to_string( numrep );
    return os;
}


inline
ostream&
operator << ( ostream& os, const sc_string& a )
{
    a.print( os );
    return os;
}
# 48 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 2







namespace sc_dt
{







typedef unsigned char uchar;



typedef int small_type;
# 119 "../../../src/systemc/datatypes/int/sc_nbdefs.h"
    typedef long long int64;
    typedef unsigned long long uint64;
    extern const uint64 UINT64_ZERO;
    extern const uint64 UINT64_ONE;
    extern const uint64 UINT64_32ONES;
# 158 "../../../src/systemc/datatypes/int/sc_nbdefs.h"
typedef ios::fmtflags fmtflags;


extern const small_type NB_DEFAULT_BASE ;







typedef int64 int_type;
typedef uint64 uint_type;

extern const uint64 UINT_ZERO;
extern const uint64 UINT_ONE;
# 192 "../../../src/systemc/datatypes/int/sc_nbdefs.h"
}
# 41 "../../../src/systemc/kernel/sc_time.h" 2
# 1 "../../../src/systemc/datatypes/fx/scfx_ieee.h" 1
# 40 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fxdefs.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fx_ids.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fx_ids.h"
# 1 "../../../src/systemc/utils/sc_report.h" 1
# 41 "../../../src/systemc/datatypes/fx/sc_fx_ids.h" 2
# 51 "../../../src/systemc/datatypes/fx/sc_fx_ids.h"
extern const char SC_ID_REGISTER_ID_FAILED_[];



extern const char SC_ID_INVALID_WL_[];

extern const char SC_ID_INVALID_N_BITS_[];

extern const char SC_ID_INVALID_DIV_WL_[];

extern const char SC_ID_INVALID_CTE_WL_[];

extern const char SC_ID_INVALID_MAX_WL_[];

extern const char SC_ID_INVALID_FX_VALUE_[];

extern const char SC_ID_INVALID_O_MODE_[];

extern const char SC_ID_OUT_OF_RANGE_[];

extern const char SC_ID_CONTEXT_BEGIN_FAILED_[];

extern const char SC_ID_CONTEXT_END_FAILED_[];

extern const char SC_ID_WRAP_SM_NOT_DEFINED_[];
# 41 "../../../src/systemc/datatypes/fx/sc_fxdefs.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_nbutils.h" 1
# 44 "../../../src/systemc/datatypes/int/sc_nbutils.h"
# 1 "/usr/include/math.h" 1 3 4
# 29 "/usr/include/math.h" 3 4
extern "C" {



# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 34 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/bits/huge_valf.h" 1 3 4
# 36 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/huge_vall.h" 1 3 4
# 37 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/inf.h" 1 3 4
# 40 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/nan.h" 1 3 4
# 43 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 36 "/usr/include/bits/mathdef.h" 3 4
typedef long double float_t;

typedef long double double_t;
# 47 "/usr/include/math.h" 2 3 4
# 70 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern double acos (double __x) throw (); extern double __acos (double __x) throw ();

extern double asin (double __x) throw (); extern double __asin (double __x) throw ();

extern double atan (double __x) throw (); extern double __atan (double __x) throw ();

extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();


extern double cos (double __x) throw (); extern double __cos (double __x) throw ();

extern double sin (double __x) throw (); extern double __sin (double __x) throw ();

extern double tan (double __x) throw (); extern double __tan (double __x) throw ();




extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();

extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();

extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();




extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();






extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();

extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();

extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();







extern double exp (double __x) throw (); extern double __exp (double __x) throw ();


extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();


extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();


extern double log (double __x) throw (); extern double __log (double __x) throw ();


extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();


extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();




extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();

extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();





extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();


extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();


extern double logb (double __x) throw (); extern double __logb (double __x) throw ();






extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();


extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();








extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();


extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();





extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();






extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();








extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));


extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));


extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));


extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();




extern int __isinf (double __value) throw () __attribute__ ((__const__));


extern int __finite (double __value) throw () __attribute__ ((__const__));





extern int isinf (double __value) throw () __attribute__ ((__const__));


extern int finite (double __value) throw () __attribute__ ((__const__));


extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();



extern double significand (double __x) throw (); extern double __significand (double __x) throw ();





extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));






extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnan (double __value) throw () __attribute__ ((__const__));



extern int isnan (double __value) throw () __attribute__ ((__const__));


extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();






extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();






extern double tgamma (double) throw (); extern double __tgamma (double) throw ();





extern double gamma (double) throw (); extern double __gamma (double) throw ();






extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();







extern double rint (double __x) throw (); extern double __rint (double __x) throw ();


extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));

extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));



extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();



extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();



extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();




extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();



extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();



extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));



extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();






extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();



extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();



extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();


extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();


extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();



extern int __fpclassify (double __value) throw ()
     __attribute__ ((__const__));


extern int __signbit (double __value) throw ()
     __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();




extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 71 "/usr/include/math.h" 2 3 4
# 93 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();

extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();

extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();

extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();


extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();

extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();

extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();




extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();

extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();

extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();




extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();






extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();

extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();

extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();







extern float expf (float __x) throw (); extern float __expf (float __x) throw ();


extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();


extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();


extern float logf (float __x) throw (); extern float __logf (float __x) throw ();


extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();


extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();




extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();

extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();





extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();


extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();


extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();






extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();


extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();








extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();


extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();





extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();






extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();








extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));


extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));


extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));


extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();




extern int __isinff (float __value) throw () __attribute__ ((__const__));


extern int __finitef (float __value) throw () __attribute__ ((__const__));





extern int isinff (float __value) throw () __attribute__ ((__const__));


extern int finitef (float __value) throw () __attribute__ ((__const__));


extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();



extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();





extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));






extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanf (float __value) throw () __attribute__ ((__const__));



extern int isnanf (float __value) throw () __attribute__ ((__const__));


extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();






extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();






extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();





extern float gammaf (float) throw (); extern float __gammaf (float) throw ();






extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();







extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();


extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));

extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));



extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();



extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();



extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();




extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();



extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();



extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));



extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();






extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();



extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();



extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();


extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();


extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();



extern int __fpclassifyf (float __value) throw ()
     __attribute__ ((__const__));


extern int __signbitf (float __value) throw ()
     __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();




extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 94 "/usr/include/math.h" 2 3 4
# 114 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4


extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();

extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();

extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();

extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();


extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();

extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();

extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();




extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();

extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();

extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();




extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();






extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();

extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();

extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();







extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();


extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();


extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();


extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();


extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();


extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();




extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();

extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();





extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();


extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();


extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();






extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();


extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();








extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();


extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();





extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();






extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();








extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));


extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));


extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();




extern int __isinfl (long double __value) throw () __attribute__ ((__const__));


extern int __finitel (long double __value) throw () __attribute__ ((__const__));





extern int isinfl (long double __value) throw () __attribute__ ((__const__));


extern int finitel (long double __value) throw () __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();



extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();





extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));






extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));





extern int __isnanl (long double __value) throw () __attribute__ ((__const__));



extern int isnanl (long double __value) throw () __attribute__ ((__const__));


extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();






extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();






extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();





extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();






extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();







extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();


extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));

extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));



extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();



extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();



extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();




extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();



extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();



extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));



extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();






extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();



extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();



extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();


extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();


extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();



extern int __fpclassifyl (long double __value) throw ()
     __attribute__ ((__const__));


extern int __signbitl (long double __value) throw ()
     __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();




extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 115 "/usr/include/math.h" 2 3 4
# 130 "/usr/include/math.h" 3 4
extern int signgam;
# 171 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN,

    FP_INFINITE,

    FP_ZERO,

    FP_SUBNORMAL,

    FP_NORMAL

  };
# 257 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 280 "/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 ();
# 382 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathinline.h" 1 3 4
# 127 "/usr/include/bits/mathinline.h" 3 4
__inline int
__signbitf (float __x) throw ()
{
  __extension__ union { float __f; int __i; } __u = { __f: __x };
  return __u.__i < 0;
}
__inline int
__signbit (double __x) throw ()
{
  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
  return __u.__i[1] < 0;
}
__inline int
__signbitl (long double __x) throw ()
{
  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
  return (__u.__i[2] & 0x8000) != 0;
}
# 291 "/usr/include/bits/mathinline.h" 3 4
__inline double __sgn (double) throw (); __inline double __sgn (double __x) throw () { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } __inline float __sgnf (float) throw (); __inline float __sgnf (float __x) throw () { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); } __inline long double __sgnl (long double) throw (); __inline long double __sgnl (long double __x) throw () { return __x == 0.0 ? 0.0 : (__x > 0.0 ? 1.0 : -1.0); }
# 433 "/usr/include/bits/mathinline.h" 3 4
__inline long double __atan2l (long double __y, long double __x) throw () { return __builtin_atan2l (__y, __x); }
# 473 "/usr/include/bits/mathinline.h" 3 4
__inline double fabs (double __x) throw () { return __builtin_fabs (__x); }

__inline float fabsf (float __x) throw () { return __builtin_fabsf (__x); }
__inline long double fabsl (long double __x) throw () { return __builtin_fabsl (__x); }

__inline long double __fabsl (long double __x) throw () { return __builtin_fabsl (__x); }
# 506 "/usr/include/bits/mathinline.h" 3 4
__inline long double __sgn1l (long double) throw (); __inline long double __sgn1l (long double __x) throw () { __extension__ union { long double __xld; unsigned int __xi[3]; } __n = { __xld: __x }; __n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff; __n.__xi[1] = 0x80000000; __n.__xi[0] = 0; return __n.__xld; }
# 530 "/usr/include/bits/mathinline.h" 3 4
__inline double floor (double __x) throw () { 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 __x) throw () { 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 __x) throw () { 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; }
# 541 "/usr/include/bits/mathinline.h" 3 4
__inline double ceil (double __x) throw () { 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 __x) throw () { 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 __x) throw () { 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; }
# 653 "/usr/include/bits/mathinline.h" 3 4
__inline long int
lrintf (float __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
__inline long int
lrint (double __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
__inline long int
lrintl (long double __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
# 676 "/usr/include/bits/mathinline.h" 3 4
__inline long long int
llrintf (float __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
__inline long long int
llrint (double __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
__inline long long int
llrintl (long double __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
# 713 "/usr/include/bits/mathinline.h" 3 4
__inline int
__finite (double __x) throw ()
{
  return (__extension__
   (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
      | 0x800fffffu) + 1) >> 31));
}
# 383 "/usr/include/math.h" 2 3 4
# 438 "/usr/include/math.h" 3 4
}
# 45 "../../../src/systemc/datatypes/int/sc_nbutils.h" 2


# 1 "../../../src/systemc/datatypes/bit/sc_bit_ids.h" 1
# 40 "../../../src/systemc/datatypes/bit/sc_bit_ids.h"
# 1 "../../../src/systemc/utils/sc_report.h" 1
# 41 "../../../src/systemc/datatypes/bit/sc_bit_ids.h" 2
# 55 "../../../src/systemc/datatypes/bit/sc_bit_ids.h"
extern const char SC_ID_LENGTH_MISMATCH_[];

extern const char SC_ID_INCOMPATIBLE_TYPES_[];

extern const char SC_ID_CANNOT_CONVERT_[];

extern const char SC_ID_INCOMPATIBLE_VECTORS_[];

extern const char SC_ID_VALUE_NOT_VALID_[];

extern const char SC_ID_ZERO_LENGTH_[];

extern const char SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_[];

extern const char SC_ID_SC_BV_CANNOT_CONTAIN_X_AND_Z_[];

extern const char SC_ID_VECTOR_TOO_LONG_[];

extern const char SC_ID_VECTOR_TOO_SHORT_[];

extern const char SC_ID_WRONG_VALUE_[];

extern const char SC_ID_LOGIC_Z_TO_BOOL_[];

extern const char SC_ID_LOGIC_X_TO_BOOL_[];
# 48 "../../../src/systemc/datatypes/int/sc_nbutils.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_int_ids.h" 1
# 40 "../../../src/systemc/datatypes/int/sc_int_ids.h"
# 1 "../../../src/systemc/utils/sc_report.h" 1
# 41 "../../../src/systemc/datatypes/int/sc_int_ids.h" 2
# 55 "../../../src/systemc/datatypes/int/sc_int_ids.h"
extern const char SC_ID_INIT_FAILED_[];
extern const char SC_ID_ASSIGNMENT_FAILED_[];
extern const char SC_ID_OPERATION_FAILED_[];
extern const char SC_ID_CONVERSION_FAILED_[];
# 49 "../../../src/systemc/datatypes/int/sc_nbutils.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 1
# 50 "../../../src/systemc/datatypes/int/sc_nbutils.h" 2



namespace sc_dt
{

inline
void
is_valid_base(sc_numrep base)
{
  switch (base) {
  case SC_NOBASE: case SC_BIN: case SC_OCT: case SC_DEC: case SC_HEX:
    break;
  case SC_BIN_US: case SC_BIN_SM:
  case SC_OCT_US: case SC_OCT_SM:
  case SC_HEX_US: case SC_HEX_SM:
      sc_report_handler::report( SC_ERROR, SC_ID_NOT_IMPLEMENTED_, "is_valid_base( sc_numrep base ) : " "base ending in _US and _SM is not supported yet", "../../../src/systemc/datatypes/int/sc_nbutils.h", 68 );


  default:
      char msg[8192];
      sprintf( msg, "is_valid_base( sc_numrep base ) : "
        "base = %s is not valid",
        to_string( base ).c_str() );
      sc_report_handler::report( SC_ERROR, SC_ID_VALUE_NOT_VALID_, msg, "../../../src/systemc/datatypes/int/sc_nbutils.h", 74 );
  }
}


extern
small_type
fsm_move(char c, small_type &b, small_type &s, small_type &state);


extern
void parse_binary_bits(
    const char* src_p, int dst_n, unsigned long* data_p, unsigned long* ctrl_p=0
);



extern
void parse_hex_bits(
    const char* src_p, int dst_n, unsigned long* data_p, unsigned long* ctrl_p=0
);



extern
const char *
get_base_and_sign(const char *v, small_type &base, small_type &sign);


extern
small_type
vec_from_str(int unb, int und, unsigned long *u,
             const char *v, sc_numrep base = SC_NOBASE) ;
# 123 "../../../src/systemc/datatypes/int/sc_nbutils.h"
extern
void
vec_add(int ulen, const unsigned long *u,
        int vlen, const unsigned long *v, unsigned long *w);

extern
void
vec_add_on(int ulen, unsigned long *u,
           int vlen, const unsigned long *v);

extern
void
vec_add_on2(int ulen, unsigned long *u,
            int vlen, const unsigned long *v);

extern
void
vec_add_small(int ulen, const unsigned long *u,
              unsigned long v, unsigned long *w);

extern
void
vec_add_small_on(int ulen, unsigned long *u, unsigned long v);






extern
void
vec_sub(int ulen, const unsigned long *u,
        int vlen, const unsigned long *v, unsigned long *w);

extern
void
vec_sub_on(int ulen, unsigned long *u,
           int vlen, const unsigned long *v);

extern
void
vec_sub_on2(int ulen, unsigned long *u,
            int vlen, const unsigned long *v);

extern
void
vec_sub_small(int ulen, const unsigned long *u,
              unsigned long v, unsigned long *w);

extern
void
vec_sub_small_on(int ulen, unsigned long *u, unsigned long v);






extern
void
vec_mul(int ulen, const unsigned long *u,
        int vlen, const unsigned long *v, unsigned long *w);

extern
void
vec_mul_small(int ulen, const unsigned long *u,
              unsigned long v, unsigned long *w);

extern
void
vec_mul_small_on(int ulen, unsigned long *u, unsigned long v);






extern
void
vec_div_large(int ulen, const unsigned long *u,
              int vlen, const unsigned long *v, unsigned long *w);

extern
void
vec_div_small(int ulen, const unsigned long *u,
              unsigned long v, unsigned long *w);






extern
void
vec_rem_large(int ulen, const unsigned long *u,
              int vlen, const unsigned long *v, unsigned long *w);

extern
unsigned long
vec_rem_small(int ulen, const unsigned long *u, unsigned long v);

extern
unsigned long
vec_rem_on_small(int ulen, unsigned long *u, unsigned long v);






extern
int
vec_to_char(int ulen, const unsigned long *u,
            int vlen, uchar *v);

extern
void
vec_from_char(int ulen, const uchar *u,
              int vlen, unsigned long *v);






extern
void
vec_shift_left(int ulen, unsigned long *u, int nsl);

extern
void
vec_shift_right(int vlen, unsigned long *u, int nsr, unsigned long fill = 0);

extern
void
vec_reverse(int unb, int und, unsigned long *ud,
            int l, int r = 0);







inline
unsigned long
low_half(unsigned long d)
{
  return (d & ((1ul << (30 / 2)) - 1));
}






inline
unsigned long
high_half(unsigned long d)
{
  return (d >> (30 / 2));
}

inline
unsigned long
high_half_masked(unsigned long d)
{
  return (high_half(d) & ((1ul << (30 / 2)) - 1));
}



inline
unsigned long
concat(unsigned long h, unsigned long l)
{
  return ((h << (30 / 2)) | l);
}


inline
unsigned long
one_and_ones(int n)
{
  return (((unsigned long) 1 << n) - 1);
}


inline
unsigned long
one_and_zeros(int n)
{
  return ((unsigned long) 1 << n);
}





inline
int
digit_ord(int i)
{
  return (i / 30);
}


inline
int
bit_ord(int i)
{
  return (i % 30);
}
# 349 "../../../src/systemc/datatypes/int/sc_nbutils.h"
inline
int
vec_cmp(int ulen, const unsigned long *u,
        int vlen, const unsigned long *v)
{
# 368 "../../../src/systemc/datatypes/int/sc_nbutils.h"
  if (ulen != vlen)
    return (ulen - vlen);


  while ((--ulen >= 0) && (u[ulen] == v[ulen]))
    ;

  if (ulen < 0)
    return 0;







  return (int) (u[ulen] - v[ulen]);

}





inline
int
vec_find_first_nonzero(int ulen, const unsigned long *u)
{






  while ((--ulen >= 0) && (! u[ulen]))
    ;

  return ulen;

}





inline
int
vec_skip_leading_zeros(int ulen, const unsigned long *u)
{






  return (1 + vec_find_first_nonzero(ulen, u));

}





inline
int
vec_skip_and_cmp(int ulen, const unsigned long *u,
                 int vlen, const unsigned long *v)
{






  ulen = vec_skip_leading_zeros(ulen, u);
  vlen = vec_skip_leading_zeros(vlen, v);

  return vec_cmp(ulen, u, vlen, v);

}


inline
void
vec_zero(int from, int ulen, unsigned long *u)
{





  for(int i = from; i < ulen; i++)
    u[i] = 0;

}


inline
void
vec_zero(int ulen, unsigned long *u)
{
  vec_zero(0, ulen, u);
}


inline
void
vec_copy(int n, unsigned long *u, const unsigned long *v)
{





  for (register int i = 0; i < n; ++i)
    u[i] = v[i];
}


inline
void
vec_copy_and_zero(int ulen, unsigned long *u,
                  int vlen, const unsigned long *v)
{







  vec_copy(vlen, u, v);
  vec_zero(vlen, ulen, u);

}


inline
void
vec_complement(int ulen, unsigned long *u)
{





  register unsigned long carry = 1;

  for (register int i = 0; i < ulen; ++i) {
    carry += (~u[i] & ((1ul << 30) - 1));
    u[i] = carry & ((1ul << 30) - 1);
    carry >>= 30;
  }

}
# 531 "../../../src/systemc/datatypes/int/sc_nbutils.h"
template< class Type >
inline
void
from_uint(int ulen, unsigned long *u, Type v)
{







  register int i = 0;

  while (v && (i < ulen)) {

    u[i++] = static_cast<unsigned long>( v & ((1ul << 30) - 1) );



    v >>= 30;
  }

  vec_zero(i, ulen, u);

}




template< class Type >
inline
small_type
get_sign(Type &u)
{
  if (u > 0)
    return 1;

  else if (u == 0)
    return 0;

  else {
    u = -u;
    return -1;
  }
}






inline
small_type
mul_signs(small_type us, small_type vs)
{
  if ((us == 0) || (vs == 0))
    return 0;

  if (us == vs)
    return 1;

  return -1;
}
# 618 "../../../src/systemc/datatypes/int/sc_nbutils.h"
template< class Type >
inline
void
div_by_zero(Type s)
{
  if (s == 0) {
      sc_report_handler::report( SC_ERROR, SC_ID_OPERATION_FAILED_, "div_by_zero<Type>( Type ) : division by zero", "../../../src/systemc/datatypes/int/sc_nbutils.h", 625 );

  }
}
# 636 "../../../src/systemc/datatypes/int/sc_nbutils.h"
inline
small_type
check_for_zero(small_type s, int ulen, const unsigned long *u)
{






  if (vec_find_first_nonzero(ulen, u) < 0)
    return 0;

  return s;

}



inline
bool
check_for_zero(int ulen, const unsigned long *u)
{






  if (vec_find_first_nonzero(ulen, u) < 0)
    return true;

  return false;

}

inline
small_type
make_zero(int nd, unsigned long *d)
{
  vec_zero(nd, d);
  return 0;
}
# 690 "../../../src/systemc/datatypes/int/sc_nbutils.h"
inline
void
trim(small_type added, int nb, int nd, unsigned long *d)
{




  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + added);
}



inline
void
convert_SM_to_2C_trimmed(small_type added,
                         small_type s, int nb, int nd, unsigned long *d)
{
  if (s == -1) {
    vec_complement(nd, d);
    trim(added, nb, nd, d);
  }
}



inline
void
convert_SM_to_2C(small_type s, int nd, unsigned long *d)
{
  if (s == -1)
    vec_complement(nd, d);
}
# 731 "../../../src/systemc/datatypes/int/sc_nbutils.h"
inline
void
trim_signed(int nb, int nd, unsigned long *d)
{




  d[nd - 1] &= one_and_ones(bit_ord(nb - 1) + 1);
}




inline
small_type
convert_signed_2C_to_SM(int nb, int nd, unsigned long *d)
{





  small_type s;

  int xnb = bit_ord(nb - 1) + 1;


  if (d[nd - 1] & one_and_zeros(xnb - 1)) {
    s = -1;
    vec_complement(nd, d);
  }
  else
    s = 1;


  d[nd - 1] &= one_and_ones(xnb);


  if (s == 1)
    return check_for_zero(s, nd, d);

  return s;

}





inline
small_type
convert_signed_SM_to_2C_to_SM(small_type s, int nb, int nd, unsigned long *d)
{
  convert_SM_to_2C(s, nd, d);
  return convert_signed_2C_to_SM(nb, nd, d);
}



inline
void
convert_signed_SM_to_2C_trimmed(small_type s, int nb, int nd, unsigned long *d)
{
  convert_SM_to_2C_trimmed(1, s, nb, nd, d);
}



inline
void
convert_signed_SM_to_2C(small_type s, int nd, unsigned long *d)
{
  convert_SM_to_2C(s, nd, d);
}
# 814 "../../../src/systemc/datatypes/int/sc_nbutils.h"
inline
void
trim_unsigned(int nb, int nd, unsigned long *d)
{




  d[nd - 1] &= one_and_ones(bit_ord(nb - 1));
}




inline
small_type
convert_unsigned_2C_to_SM(int nb, int nd, unsigned long *d)
{
  trim_unsigned(nb, nd, d);
  return check_for_zero(1, nd, d);
}





inline
small_type
convert_unsigned_SM_to_2C_to_SM(small_type s, int nb, int nd, unsigned long *d)
{
  convert_SM_to_2C(s, nd, d);
  return convert_unsigned_2C_to_SM(nb, nd, d);
}



inline
void
convert_unsigned_SM_to_2C_trimmed(small_type s, int nb, int nd, unsigned long *d)
{
  convert_SM_to_2C_trimmed(0, s, nb, nd, d);
}



inline
void
convert_unsigned_SM_to_2C(small_type s, int nd, unsigned long *d)
{
  convert_SM_to_2C(s, nd, d);
}







inline
void
copy_digits_signed(small_type &us,
                   int unb, int und, unsigned long *ud,
                   int vnb, int vnd, const unsigned long *vd)
{

  if (und <= vnd) {

    vec_copy(und, ud, vd);

    if (unb <= vnb)
      us = convert_signed_SM_to_2C_to_SM(us, unb, und, ud);

  }
  else
    vec_copy_and_zero(und, ud, vnd, vd);

}


inline
void
copy_digits_unsigned(small_type &us,
                     int unb, int und, unsigned long *ud,
                     int vnb, int vnd, const unsigned long *vd)
{

  if (und <= vnd)
    vec_copy(und, ud, vd);

  else
    vec_copy_and_zero(und, ud, vnd, vd);

  us = convert_unsigned_SM_to_2C_to_SM(us, unb, und, ud);

}







inline
void
safe_set(int i, bool v, unsigned long *d)
{





  int bit_num = bit_ord(i);
  int digit_num = digit_ord(i);

  if (v)
    d[digit_num] |= one_and_zeros(bit_num);
  else
    d[digit_num] &= ~(one_and_zeros(bit_num));

}






inline
void
is_bad_double(double v)
{
# 957 "../../../src/systemc/datatypes/int/sc_nbutils.h"
}

}
# 42 "../../../src/systemc/datatypes/fx/sc_fxdefs.h" 2
# 1 "../../../src/systemc/utils/sc_string.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_fxdefs.h" 2


namespace sc_dt
{







enum sc_enc
{
    SC_TC_,
    SC_US_
};


const sc_string to_string( sc_enc );


inline
ostream&
operator << ( ostream& os, sc_enc enc )
{
    return os << to_string( enc );
}
# 78 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
enum sc_q_mode
{
    SC_RND,
    SC_RND_ZERO,
    SC_RND_MIN_INF,
    SC_RND_INF,
    SC_RND_CONV,
    SC_TRN,
    SC_TRN_ZERO
};


const sc_string to_string( sc_q_mode );


inline
ostream&
operator << ( ostream& os, sc_q_mode q_mode )
{
    return os << to_string( q_mode );
}
# 107 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
enum sc_o_mode
{
    SC_SAT,
    SC_SAT_ZERO,
    SC_SAT_SYM,
    SC_WRAP,
    SC_WRAP_SM
};




const sc_string to_string( sc_o_mode );


inline
ostream&
operator << ( ostream& os, sc_o_mode o_mode )
{
    return os << to_string( o_mode );
}
# 136 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
enum sc_switch
{
    SC_OFF,
    SC_ON
};


const sc_string to_string( sc_switch );


inline
ostream&
operator << ( ostream& os, sc_switch sw )
{
    return os << to_string( sw );
}
# 160 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
enum sc_fmt
{
    SC_F,
    SC_E
};


const sc_string to_string( sc_fmt );


inline
ostream&
operator << ( ostream& os, sc_fmt fmt )
{
    return os << to_string( fmt );
}






const int SC_BUILTIN_WL_ = 32;
const int SC_BUILTIN_IWL_ = 32;
const sc_q_mode SC_BUILTIN_Q_MODE_ = SC_TRN;
const sc_o_mode SC_BUILTIN_O_MODE_ = SC_WRAP;
const int SC_BUILTIN_N_BITS_ = 0;


const int SC_DEFAULT_WL_ = SC_BUILTIN_WL_;
const int SC_DEFAULT_IWL_ = SC_BUILTIN_IWL_;
const sc_q_mode SC_DEFAULT_Q_MODE_ = SC_BUILTIN_Q_MODE_;
const sc_o_mode SC_DEFAULT_O_MODE_ = SC_BUILTIN_O_MODE_;
const int SC_DEFAULT_N_BITS_ = SC_BUILTIN_N_BITS_;






const sc_switch SC_BUILTIN_CAST_SWITCH_ = SC_ON;


const sc_switch SC_DEFAULT_CAST_SWITCH_ = SC_BUILTIN_CAST_SWITCH_;






const int SC_BUILTIN_DIV_WL_ = 64;
const int SC_BUILTIN_CTE_WL_ = 64;
const int SC_BUILTIN_MAX_WL_ = 1024;





const int SC_DEFAULT_DIV_WL_ = SC_BUILTIN_DIV_WL_;





const int SC_DEFAULT_CTE_WL_ = SC_BUILTIN_CTE_WL_;





const int SC_DEFAULT_MAX_WL_ = SC_BUILTIN_MAX_WL_;
# 291 "../../../src/systemc/datatypes/fx/sc_fxdefs.h"
}
# 41 "../../../src/systemc/datatypes/fx/scfx_ieee.h" 2


namespace sc_dt
{


union ieee_double;
class scfx_ieee_double;
union ieee_float;
class scfx_ieee_float;
# 70 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
union ieee_double
{

    double d;

    struct
    {






        unsigned mantissa1:32;
        unsigned mantissa0:20;
        unsigned exponent:11;
        unsigned negative:1;

    } s;

};


const unsigned int SCFX_IEEE_DOUBLE_BIAS = 1023U;

const int SCFX_IEEE_DOUBLE_E_MAX = 1023;
const int SCFX_IEEE_DOUBLE_E_MIN = -1022;

const unsigned int SCFX_IEEE_DOUBLE_M_SIZE = 52;
# 107 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
class scfx_ieee_double
{

    ieee_double m_id;

public:

    scfx_ieee_double();
    scfx_ieee_double( double );
    scfx_ieee_double( const scfx_ieee_double& );

    scfx_ieee_double& operator = ( double );
    scfx_ieee_double& operator = ( const scfx_ieee_double& );

    operator double() const;

    unsigned int negative() const;
    void negative( unsigned int );
    int exponent() const;
    void exponent( int );
    unsigned int mantissa0() const;
    void mantissa0( unsigned int );
    unsigned int mantissa1() const;
    void mantissa1( unsigned int );

    bool is_zero() const;
    bool is_subnormal() const;
    bool is_normal() const;
    bool is_inf() const;
    bool is_nan() const;

    void set_inf();
    void set_nan();

    int msb() const;
    int lsb() const;

    static const scfx_ieee_double nan();
    static const scfx_ieee_double inf( int );

};




inline
scfx_ieee_double::scfx_ieee_double()
{
    m_id.d = 0.0;
}

inline
scfx_ieee_double::scfx_ieee_double( double d )
{
    m_id.d = d;
}

inline
scfx_ieee_double::scfx_ieee_double( const scfx_ieee_double& a )
{
    m_id.d = a.m_id.d;
}


inline
scfx_ieee_double&
scfx_ieee_double::operator = ( double d )
{
    m_id.d = d;
    return *this;
}

inline
scfx_ieee_double&
scfx_ieee_double::operator = ( const scfx_ieee_double& a )
{
    m_id.d = a.m_id.d;
    return *this;
}


inline
scfx_ieee_double::operator double() const
{
    return m_id.d;
}


inline
unsigned int
scfx_ieee_double::negative() const
{
    return m_id.s.negative;
}

inline
void
scfx_ieee_double::negative( unsigned int a )
{
    m_id.s.negative = a;
}

inline
int
scfx_ieee_double::exponent() const
{
    return m_id.s.exponent - SCFX_IEEE_DOUBLE_BIAS;
}

inline
void
scfx_ieee_double::exponent( int a )
{
    m_id.s.exponent = SCFX_IEEE_DOUBLE_BIAS + a;
}

inline
unsigned int
scfx_ieee_double::mantissa0() const
{
    return m_id.s.mantissa0;
}

inline
void
scfx_ieee_double::mantissa0( unsigned int a )
{
    m_id.s.mantissa0 = a;
}

inline
unsigned int
scfx_ieee_double::mantissa1() const
{
    return m_id.s.mantissa1;
}

inline
void
scfx_ieee_double::mantissa1( unsigned int a )
{
    m_id.s.mantissa1 = a;
}


inline
bool
scfx_ieee_double::is_zero() const
{
    return ( exponent() == SCFX_IEEE_DOUBLE_E_MIN - 1 &&
             mantissa0() == 0U && mantissa1() == 0U );
}

inline
bool
scfx_ieee_double::is_subnormal() const
{
    return ( exponent() == SCFX_IEEE_DOUBLE_E_MIN - 1 &&
             ( mantissa0() != 0U || mantissa1() != 0U ) );
}

inline
bool
scfx_ieee_double::is_normal() const
{
    return ( exponent() >= SCFX_IEEE_DOUBLE_E_MIN &&
             exponent() <= SCFX_IEEE_DOUBLE_E_MAX );
}

inline
bool
scfx_ieee_double::is_inf() const
{
    return ( exponent() == SCFX_IEEE_DOUBLE_E_MAX + 1 &&
             mantissa0() == 0U && mantissa1() == 0U );
}

inline
bool
scfx_ieee_double::is_nan() const
{
    return ( exponent() == SCFX_IEEE_DOUBLE_E_MAX + 1 &&
             ( mantissa0() != 0U || mantissa1() != 0U ) );
}


inline
void
scfx_ieee_double::set_inf()
{
    exponent( SCFX_IEEE_DOUBLE_E_MAX + 1 );
    mantissa0( 0U );
    mantissa1( 0U );
}

inline
void
scfx_ieee_double::set_nan()
{
    exponent( SCFX_IEEE_DOUBLE_E_MAX + 1 );
    mantissa0( (unsigned int) -1 );
    mantissa1( (unsigned int) -1 );
}




inline
int
scfx_ieee_double::msb() const
{
    unsigned int m0 = mantissa0();
    unsigned int m1 = mantissa1();
    if( m0 != 0 )
    {
        int i = 0;
        if( m0 >> 16 ) { m0 >>= 16; i += 16; };
        if( m0 >> 8 ) { m0 >>= 8; i += 8; };
        if( m0 >> 4 ) { m0 >>= 4; i += 4; };
        if( m0 >> 2 ) { m0 >>= 2; i += 2; };
        if( m0 >> 1 ) { m0 >>= 1; i += 1; };
        return ( i - 20 );
    }
    else if( m1 != 0 )
    {
        int i = 0;
        if( m1 >> 16 ) { m1 >>= 16; i += 16; };
        if( m1 >> 8 ) { m1 >>= 8; i += 8; };
        if( m1 >> 4 ) { m1 >>= 4; i += 4; };
        if( m1 >> 2 ) { m1 >>= 2; i += 2; };
        if( m1 >> 1 ) { m1 >>= 1; i += 1; };
        return ( i - 52 );
    }
    else
    {
        return 0;
    }
}





inline
int
scfx_ieee_double::lsb() const
{
    unsigned int m0 = mantissa0();
    unsigned int m1 = mantissa1();
    if( m1 != 0 )
    {
        int i = 31;
        if( m1 << 16 ) { m1 <<= 16; i -= 16; };
        if( m1 << 8 ) { m1 <<= 8; i -= 8; };
        if( m1 << 4 ) { m1 <<= 4; i -= 4; };
        if( m1 << 2 ) { m1 <<= 2; i -= 2; };
        if( m1 << 1 ) { m1 <<= 1; i -= 1; };
        return ( i - 52 );
    }
    else if( m0 != 0 )
    {
        int i = 31;
        if( m0 << 16 ) { m0 <<= 16; i -= 16; };
        if( m0 << 8 ) { m0 <<= 8; i -= 8; };
        if( m0 << 4 ) { m0 <<= 4; i -= 4; };
        if( m0 << 2 ) { m0 <<= 2; i -= 2; };
        if( m0 << 1 ) { m0 <<= 1; i -= 1; };
        return ( i - 20 );
    }
    else
    {
        return 0;
    }
}




inline
const scfx_ieee_double
scfx_ieee_double::nan()
{
    scfx_ieee_double id;
    id.set_nan();
    return id;
}

inline
const scfx_ieee_double
scfx_ieee_double::inf( int sign )
{
    scfx_ieee_double id( sign );
    id.set_inf();
    return id;
}
# 410 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
union ieee_float
{

    float f;

    struct
    {





        unsigned mantissa:23;
        unsigned exponent:8;
        unsigned negative:1;

    } s;

};


const unsigned int SCFX_IEEE_FLOAT_BIAS = 127U;

const int SCFX_IEEE_FLOAT_E_MAX = 127;
const int SCFX_IEEE_FLOAT_E_MIN = -126;

const unsigned int SCFX_IEEE_FLOAT_M_SIZE = 23;
# 445 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
class scfx_ieee_float
{

    ieee_float m_if;

public:

    scfx_ieee_float();
    scfx_ieee_float( float );
    scfx_ieee_float( const scfx_ieee_float& );

    scfx_ieee_float& operator = ( float );
    scfx_ieee_float& operator = ( const scfx_ieee_float& );

    operator float() const;

    unsigned int negative() const;
    void negative( unsigned int );
    int exponent() const;
    void exponent( int );
    unsigned int mantissa() const;
    void mantissa( unsigned int );

    bool is_zero() const;
    bool is_subnormal() const;
    bool is_normal() const;
    bool is_inf() const;
    bool is_nan() const;

    void set_inf();
    void set_nan();

};




inline
scfx_ieee_float::scfx_ieee_float()
{
    m_if.f = 0.0;
}

inline
scfx_ieee_float::scfx_ieee_float( float f )
{
    m_if.f = f;
}

inline
scfx_ieee_float::scfx_ieee_float( const scfx_ieee_float& a )
{
    m_if.f = a.m_if.f;
}


inline
scfx_ieee_float&
scfx_ieee_float::operator = ( float f )
{
    m_if.f = f;
    return *this;
}

inline
scfx_ieee_float&
scfx_ieee_float::operator = ( const scfx_ieee_float& a )
{
    m_if.f = a.m_if.f;
    return *this;
}


inline
scfx_ieee_float::operator float() const
{
    return m_if.f;
}


inline
unsigned int
scfx_ieee_float::negative() const
{
    return m_if.s.negative;
}

inline
void
scfx_ieee_float::negative( unsigned int a )
{
    m_if.s.negative = a;
}

inline
int
scfx_ieee_float::exponent() const
{
    return m_if.s.exponent - SCFX_IEEE_FLOAT_BIAS;
}

inline
void
scfx_ieee_float::exponent( int a )
{
    m_if.s.exponent = SCFX_IEEE_FLOAT_BIAS + a;
}

inline
unsigned int
scfx_ieee_float::mantissa() const
{
    return m_if.s.mantissa;
}

inline
void
scfx_ieee_float::mantissa( unsigned int a )
{
    m_if.s.mantissa = a;
}


inline
bool
scfx_ieee_float::is_zero() const
{
    return ( exponent() == SCFX_IEEE_FLOAT_E_MIN - 1 && mantissa() == 0U );
}

inline
bool
scfx_ieee_float::is_subnormal() const
{
    return ( exponent() == SCFX_IEEE_FLOAT_E_MIN - 1 && mantissa() != 0U );
}

inline
bool
scfx_ieee_float::is_normal() const
{
    return ( exponent() >= SCFX_IEEE_FLOAT_E_MIN &&
             exponent() <= SCFX_IEEE_FLOAT_E_MAX );
}

inline
bool
scfx_ieee_float::is_inf() const
{
    return ( exponent() == SCFX_IEEE_FLOAT_E_MAX + 1 && mantissa() == 0U );
}

inline
bool
scfx_ieee_float::is_nan() const
{
    return ( exponent() == SCFX_IEEE_FLOAT_E_MAX + 1 && mantissa() != 0U );
}


inline
void
scfx_ieee_float::set_inf()
{
    exponent( SCFX_IEEE_FLOAT_E_MAX + 1 );
    mantissa( 0U );
}

inline
void
scfx_ieee_float::set_nan()
{
    exponent( SCFX_IEEE_FLOAT_E_MAX + 1 );
    mantissa( (unsigned int) -1 );
}
# 628 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
inline
double scfx_pow2( int exp )
{
    scfx_ieee_double r;
    if( exp < SCFX_IEEE_DOUBLE_E_MIN )
    {
        r = 0.0;

        exp -= SCFX_IEEE_DOUBLE_E_MIN;
        if( ( exp += 20 ) >= 0 )
 {
            r.mantissa0( 1U << exp );
        }
 else if( ( exp += 32 ) >= 0 )
 {
            r.mantissa1( 1U << exp );
        }
    }
    else if( exp > SCFX_IEEE_DOUBLE_E_MAX )
    {
        r.set_inf();
    }
    else
    {
        r = 1.0;
        r.exponent( exp );
    }
    return r;
}
# 666 "../../../src/systemc/datatypes/fx/scfx_ieee.h"
inline
double
uint64_to_double( uint64 a )
{





    return static_cast<double>( a );

}

}
# 42 "../../../src/systemc/kernel/sc_time.h" 2

# 1 "../../../src/systemc/utils/sc_string.h" 1
# 44 "../../../src/systemc/kernel/sc_time.h" 2

using sc_dt::int64;
using sc_dt::uint64;

class sc_simcontext;
# 57 "../../../src/systemc/kernel/sc_time.h"
enum sc_time_unit
{
    SC_FS = 0,
    SC_PS,
    SC_NS,
    SC_US,
    SC_MS,
    SC_SEC
};
# 74 "../../../src/systemc/kernel/sc_time.h"
class sc_time
{
public:



    sc_time();
    sc_time( double, sc_time_unit );
    sc_time( double, sc_time_unit, sc_simcontext* );
    sc_time( double, bool scale );
    sc_time( uint64, bool scale );
    sc_time( const sc_time& );




    sc_time& operator = ( const sc_time& );




    uint64 value() const;
    double to_double() const;
    double to_default_time_units() const;
    double to_seconds() const;
    const sc_string to_string() const;




    bool operator == ( const sc_time& ) const;
    bool operator != ( const sc_time& ) const;
    bool operator < ( const sc_time& ) const;
    bool operator <= ( const sc_time& ) const;
    bool operator > ( const sc_time& ) const;
    bool operator >= ( const sc_time& ) const;




    sc_time& operator += ( const sc_time& );
    sc_time& operator -= ( const sc_time& );

    friend const sc_time operator + ( const sc_time&, const sc_time& );
    friend const sc_time operator - ( const sc_time&, const sc_time& );

    sc_time& operator *= ( double );
    sc_time& operator /= ( double );

    friend const sc_time operator * ( const sc_time&, double );
    friend const sc_time operator * ( double, const sc_time& );
    friend const sc_time operator / ( const sc_time&, double );
    friend double operator / ( const sc_time&, const sc_time& );




    void print( ostream& ) const;

private:

    uint64 m_value;
};




inline ostream& operator << ( ostream&, const sc_time& );






inline
sc_time::sc_time()
: m_value( 0 )
{}

inline
sc_time::sc_time( const sc_time& t )
: m_value( t.m_value )
{}




inline
sc_time&
sc_time::operator = ( const sc_time& t )
{
    m_value = t.m_value;
    return *this;
}




inline
uint64
sc_time::value() const
{
    return m_value;
}


inline
double
sc_time::to_double() const
{
    return sc_dt::uint64_to_double( m_value );
}




inline
bool
sc_time::operator == ( const sc_time& t ) const
{
    return ( m_value == t.m_value );
}

inline
bool
sc_time::operator != ( const sc_time& t ) const
{
    return ( m_value != t.m_value );
}

inline
bool
sc_time::operator < ( const sc_time& t ) const
{
    return ( m_value < t.m_value );
}

inline
bool
sc_time::operator <= ( const sc_time& t ) const
{
    return ( m_value <= t.m_value );
}

inline
bool
sc_time::operator > ( const sc_time& t ) const
{
    return ( m_value > t.m_value );
}

inline
bool
sc_time::operator >= ( const sc_time& t ) const
{
    return ( m_value >= t.m_value );
}




inline
sc_time&
sc_time::operator += ( const sc_time& t )
{
    m_value += t.m_value;
    return *this;
}

inline
sc_time&
sc_time::operator -= ( const sc_time& t )
{
    m_value -= t.m_value;
    return *this;
}


inline
const sc_time
operator + ( const sc_time& t1, const sc_time& t2 )
{
    return sc_time( t1 ) += t2;
}

inline
const sc_time
operator - ( const sc_time& t1, const sc_time& t2 )
{
    return sc_time( t1 ) -= t2;
}


inline
sc_time&
sc_time::operator *= ( double d )
{

    volatile double tmp = sc_dt::uint64_to_double( m_value ) * d + 0.5;
    m_value = static_cast<int64>( tmp );
    return *this;
}

inline
sc_time&
sc_time::operator /= ( double d )
{

    volatile double tmp = sc_dt::uint64_to_double( m_value ) / d + 0.5;
    m_value = static_cast<int64>( tmp );
    return *this;
}


inline
const sc_time
operator * ( const sc_time& t, double d )
{
    sc_time tmp( t );
    return tmp *= d;
}

inline
const sc_time
operator * ( double d, const sc_time& t )
{
    sc_time tmp( t );
    return tmp *= d;
}

inline
const sc_time
operator / ( const sc_time& t, double d )
{
    sc_time tmp( t );
    return tmp /= d;
}

inline
double
operator / ( const sc_time& t1, const sc_time& t2 )
{
    return ( t1.to_double() / t2.to_double() );
}




inline
ostream&
operator << ( ostream& os, const sc_time& t )
{
    t.print( os );
    return os;
}
# 337 "../../../src/systemc/kernel/sc_time.h"
struct sc_time_params
{
    double time_resolution;
    bool time_resolution_specified;
    bool time_resolution_fixed;

    uint64 default_time_unit;
    bool default_time_unit_specified;

    sc_time_params();
    ~sc_time_params();
};




extern const sc_time SC_ZERO_TIME;




extern void sc_set_time_resolution( double, sc_time_unit );
extern sc_time sc_get_time_resolution();

extern void sc_set_default_time_unit( double, sc_time_unit );
extern sc_time sc_get_default_time_unit();
# 61 "../../../src/systemc/kernel/sc_simcontext.h" 2
# 1 "../../../src/systemc/utils/sc_hash.h" 1
# 44 "../../../src/systemc/utils/sc_hash.h"
extern unsigned default_int_hash_fn(const void*);
extern unsigned default_ptr_hash_fn(const void*);
extern unsigned default_str_hash_fn(const void*);

class sc_phash_elem;
class sc_phash_base_iter;
template<class K, class C>
class sc_pdhash_iter;

const int PHASH_DEFAULT_MAX_DENSITY = 5;
const int PHASH_DEFAULT_INIT_TABLE_SIZE = 11;
extern const double PHASH_DEFAULT_GROW_FACTOR;
const bool PHASH_DEFAULT_REORDER_FLAG = true;

class sc_phash_base {
    friend class sc_phash_base_iter;

    typedef sc_phash_base_iter iterator;

public:
    typedef unsigned (*hash_fn_t)(const void*);
    typedef int (*cmpr_fn_t)(const void*, const void*);

protected:
    void* default_value;
    int num_bins;
    int num_entries;
    int max_density;
    int reorder_flag;
    double grow_factor;

    sc_phash_elem** bins;

    hash_fn_t hash;
    cmpr_fn_t cmpr;

    void rehash();
    unsigned do_hash(const void* key) const { return (*hash)(key) % num_bins; }

    sc_phash_elem* add_direct(void* key, void* contents, unsigned hash_val);
    sc_phash_elem* find_entry_c(unsigned hv, const void* k, sc_phash_elem*** plast);
    sc_phash_elem* find_entry_q(unsigned hv, const void* k, sc_phash_elem*** plast);
    sc_phash_elem* find_entry(unsigned hv, const void* k, sc_phash_elem*** plast=0) const
    {


      if( cmpr == 0 )
        return ((sc_phash_base*)this)->find_entry_q( hv, k, plast );
      else
 return ((sc_phash_base*)this)->find_entry_c( hv, k, plast );
    }

public:
    sc_phash_base( void* def = 0,
                   int size = PHASH_DEFAULT_INIT_TABLE_SIZE,
                   int density = PHASH_DEFAULT_MAX_DENSITY,
                   double grow = PHASH_DEFAULT_GROW_FACTOR,
                   bool reorder = PHASH_DEFAULT_REORDER_FLAG,
                   hash_fn_t hash_fn = default_ptr_hash_fn,
                   cmpr_fn_t cmpr_fn = 0 );
    ~sc_phash_base();

    void set_cmpr_fn(cmpr_fn_t);
    void set_hash_fn(hash_fn_t);

    bool empty() const { return (num_entries == 0); }
    unsigned count() const { return num_entries; }

    void erase();
    void erase(void (*kfree)(void*));
    void copy( const sc_phash_base* );
    void copy( const sc_phash_base& b ) { copy(&b); }
    void copy( const sc_phash_base& b, void* (*kdup)(const void*), void (*kfree)(void*));
    int insert( void* k, void* c );
    int insert( void* k ) { return insert(k, default_value); }
    int insert( void* k, void* c, void* (*kdup)(const void*) );
    int insert_if_not_exists(void* k, void* c);
    int insert_if_not_exists(void* k) { return insert_if_not_exists(k, default_value); }
    int insert_if_not_exists(void* k, void* c, void* (*kdup)(const void*));
    int remove(const void* k);
    int remove(const void* k, void** pk, void** pc);
    int remove(const void* k, void (*kfree)(void*));
    int remove_by_contents(const void* c);
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg);
    int remove_by_contents(const void* c, void (*kfree)(void*));
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg, void (*kfree)(void*));
    int lookup(const void* k, void** pc) const;
    bool contains(const void* k) const { return (lookup(k, 0) != 0); }
    void* operator[](const void* key) const;
};

class sc_phash_base_iter {
protected:
    sc_phash_base* table;
    sc_phash_elem* entry;
    sc_phash_elem* next;
    sc_phash_elem** last;
    int index;

public:
    void reset(sc_phash_base* t);
    void reset(sc_phash_base& t) { reset(&t); }

    sc_phash_base_iter(sc_phash_base* t) { reset(t); }
    sc_phash_base_iter(sc_phash_base& t) { reset(t); }
    ~sc_phash_base_iter() { }

    bool empty() const;
    void step();
    void operator++(int) { step(); }
    void remove();
    void remove(void (*kfree)(void*));
    void* key() const;
    void* contents() const;
    void* set_contents(void* c);
};

template< class K, class C >
class sc_phash_iter;

template< class K, class C >
class sc_phash : public sc_phash_base {
    friend class sc_phash_iter<K,C>;

public:
    typedef sc_phash_iter<K,C> iterator;

    sc_phash( C def = (C) 0,
              int size = PHASH_DEFAULT_INIT_TABLE_SIZE,
              int density = PHASH_DEFAULT_MAX_DENSITY,
              double grow = PHASH_DEFAULT_GROW_FACTOR,
              bool reorder = PHASH_DEFAULT_REORDER_FLAG,
              hash_fn_t hash_fn = default_ptr_hash_fn,
              cmpr_fn_t cmpr_fn = 0 )
        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn) { }
    ~sc_phash() { }

    void copy(const sc_phash<K,C>* b) { sc_phash_base::copy(b); }
    void copy(const sc_phash<K,C>& b) { sc_phash_base::copy(b); }
    void copy(const sc_phash<K,C>& b, void* (*kdup)(const void*), void (*kfree)(void*)) { sc_phash_base::copy(b, kdup, kfree); }

    int insert(K k, C c) { return sc_phash_base::insert((void*) k, (void*) c); }
    int insert(K k) { return sc_phash_base::insert((void*) k, default_value); }
    int insert(K k, C c, void* (*kdup)(const void*)) { return sc_phash_base::insert((void*) k, (void*) c, kdup); }
    int insert_if_not_exists(K k, C c)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c);
    }
    int insert_if_not_exists(K k)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, default_value);
    }
    int insert_if_not_exists(K k, C c, void* (*kdup)(const void*))
    {
        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, kdup);
    }
    int remove(K k) { return sc_phash_base::remove((const void*) k); }
    int remove(K k, K* pk, C* pc)
    {
        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
    }
    int remove(K k, void (*kfree)(void*))
    {
        return sc_phash_base::remove((const void*) k, kfree);
    }
    int remove_by_contents(C c)
    {
        return sc_phash_base::remove_by_contents((const void*) c);
    }
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
    {
        return sc_phash_base::remove_by_contents(predicate, arg);
    }
    int remove_by_contents(const void* c, void (*kfree)(void*))
    {
        return sc_phash_base::remove_by_contents(c, kfree);
    }
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg, void (*kfree)(void*))
    {
        return sc_phash_base::remove_by_contents(predicate, arg, kfree);
    }
    int lookup(K k, C* pc) const
    {
        return sc_phash_base::lookup((const void*) k, (void**) pc);
    }
    bool contains(K k) const
    {
        return sc_phash_base::contains((const void*) k);
    }
    C operator[](K k) const
    {
        return (C) sc_phash_base::operator[]((const void*) k);
    }
};


template< class K, class C >
class sc_phash_iter : public sc_phash_base_iter {
public:
    sc_phash_iter(sc_phash<K,C>* t) : sc_phash_base_iter(t) { }
    sc_phash_iter(sc_phash<K,C>& t) : sc_phash_base_iter(t) { }
    ~sc_phash_iter() { }

    void reset(sc_phash<K,C>* t) { sc_phash_base_iter::reset(t); }
    void reset(sc_phash<K,C>& t) { sc_phash_base_iter::reset(t); }

    K key() const { return (K) sc_phash_base_iter::key(); }
    C contents() const { return (C) sc_phash_base_iter::contents(); }
    C set_contents(C c)
    {
        return (C) sc_phash_base_iter::set_contents((void*) c);
    }
};





template< class K, class C >
class sc_pdhash : public sc_phash_base {
    friend class sc_pdhash_iter<K,C>;

private:
    void* (*kdup)(const void*);
    void (*kfree)(void*);

public:
    typedef sc_pdhash_iter<K,C> iterator;
    sc_pdhash( C def = (C) 0,
              int size = PHASH_DEFAULT_INIT_TABLE_SIZE,
              int density = PHASH_DEFAULT_MAX_DENSITY,
              double grow = PHASH_DEFAULT_GROW_FACTOR,
              bool reorder = PHASH_DEFAULT_REORDER_FLAG,
              hash_fn_t hash_fn = (hash_fn_t) 0,
              cmpr_fn_t cmpr_fn = (cmpr_fn_t) 0,
              void* (*kdup_fn)(const void*) = 0,
              void (*kfree_fn)(void*) = 0 )
        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn)
    {
        kdup = kdup_fn;
        kfree = kfree_fn;
    }
    ~sc_pdhash()
    {
        erase();
    }
    void erase()
    {
        sc_phash_base::erase(kfree);
    }
    void copy(const sc_pdhash<K,C>& b) { sc_phash_base::copy(b, kdup, kfree); }
    int insert(K k, C c) { return sc_phash_base::insert((void*) k, (void*) c, kdup); }
    int insert(K k) { return sc_phash_base::insert((void*) k, default_value, kdup); }
    int insert_if_not_exists(K k, C c)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, kdup);
    }
    int insert_if_not_exists(K k)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, default_value, kdup);
    }
    int remove(K k) { return sc_phash_base::remove((const void*) k, kfree); }
    int remove(K k, K* pk, C* pc)
    {
        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
    }
    int remove_by_contents(C c)
    {
        return sc_phash_base::remove_by_contents((const void*) c, kfree);
    }
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
    {
        return sc_phash_base::remove_by_contents(predicate, arg, kfree);
    }
    int lookup(K k, C* pc) const
    {
        return sc_phash_base::lookup((const void*) k, (void**) pc);
    }
    bool contains(K k) const
    {
        return sc_phash_base::contains((const void*) k);
    }
    C operator[](K k) const
    {
        return (C) sc_phash_base::operator[]((const void*) k);
    }
};

template< class K, class C >
class sc_pdhash_iter : public sc_phash_base_iter {
public:
    sc_pdhash_iter(sc_pdhash<K,C>* t) : sc_phash_base_iter(t) { }
    sc_pdhash_iter(sc_pdhash<K,C>& t) : sc_phash_base_iter(t) { }
    ~sc_pdhash_iter() { }

    void reset(sc_pdhash<K,C>* t) { sc_phash_base_iter::reset(t); }
    void reset(sc_pdhash<K,C>& t) { sc_phash_base_iter::reset(t); }

    void remove() { sc_phash_base_iter::remove(((sc_pdhash<K,C>*) table)->kfree); }
    K key() const { return (K) sc_phash_base_iter::key(); }
    C contents() const { return (C) sc_phash_base_iter::contents(); }
    C set_contents(C c)
    {
        return (C) sc_phash_base_iter::set_contents((void*) c);
    }
};

extern int sc_strhash_cmp( const void*, const void* );
extern void sc_strhash_kfree(void*);
extern void* sc_strhash_kdup(const void*);

template< class C >
class sc_strhash_iter;

template< class C >
class sc_strhash : public sc_phash_base {
    friend class sc_strhash_iter<C>;

public:
    typedef sc_strhash_iter<C> iterator;

    sc_strhash( C def = (C) 0,
                int size = PHASH_DEFAULT_INIT_TABLE_SIZE,
                int density = PHASH_DEFAULT_MAX_DENSITY,
                double grow = PHASH_DEFAULT_GROW_FACTOR,
                bool reorder = PHASH_DEFAULT_REORDER_FLAG,
                unsigned (*hash_fn)(const void*) = default_str_hash_fn,
                int (*cmpr_fn)(const void*, const void*) = sc_strhash_cmp )
        : sc_phash_base((void*) def, size, density, grow, reorder, hash_fn, cmpr_fn)
    {

    }
    ~sc_strhash()
    {
        erase();
    }

    void erase() { sc_phash_base::erase(sc_strhash_kfree); }
    void copy(const sc_strhash<C>* b) { sc_phash_base::copy(*b, sc_strhash_kdup, sc_strhash_kfree); }
    void copy(const sc_strhash<C>& b) { sc_phash_base::copy(b, sc_strhash_kdup, sc_strhash_kfree); }

    int insert(char* k, C c) { return sc_phash_base::insert((void*) k, (void*) c, sc_strhash_kdup); }
    int insert(char* k) { return sc_phash_base::insert((void*) k, default_value, sc_strhash_kdup); }
    int insert_if_not_exists(char* k, C c)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, (void*) c, sc_strhash_kdup);
    }
    int insert_if_not_exists(char* k)
    {
        return sc_phash_base::insert_if_not_exists((void*) k, default_value, sc_strhash_kdup);
    }
    int remove(const char* k) { return sc_phash_base::remove((const void*) k, sc_strhash_kfree); }
    int remove(const char* k, char** pk, C* pc)
    {
        return sc_phash_base::remove((const void*) k, (void**) pk, (void**) pc);
    }
    int remove_by_contents(C c)
    {
        return sc_phash_base::remove_by_contents((const void*) c, sc_strhash_kfree);
    }
    int remove_by_contents(bool (*predicate)(const void*, void*), void* arg)
    {
        return sc_phash_base::remove_by_contents(predicate, arg, sc_strhash_kfree);
    }
    int lookup(const char* k, C* pc) const
    {
        return sc_phash_base::lookup((const void*) k, (void** )pc);
    }
    bool contains(const char* k) const
    {
        return sc_phash_base::contains((const void*) k);
    }
    C operator[](const char* k) const
    {
        return (C) sc_phash_base::operator[]((const void*) k);
    }
};

template<class C>
class sc_strhash_iter : public sc_phash_base_iter {
public:
    sc_strhash_iter ( sc_strhash<C>* t ) : sc_phash_base_iter(t) { }
    sc_strhash_iter ( sc_strhash<C>& t ) : sc_phash_base_iter(t) { }
    ~sc_strhash_iter() { }

    void reset ( sc_strhash<C>* t ) { sc_phash_base_iter::reset(t); }
    void reset ( sc_strhash<C>& t ) { sc_phash_base_iter::reset(t); }

    void remove() { sc_phash_base_iter::remove(sc_strhash_kfree); }
    const char* key() { return (const char*) sc_phash_base_iter::key(); }
    C contents() { return (C) sc_phash_base_iter::contents(); }
    C set_contents(C c)
    {
        return (C) sc_phash_base_iter::set_contents((void*) c);
    }
};
# 62 "../../../src/systemc/kernel/sc_simcontext.h" 2
# 1 "../../../src/systemc/utils/sc_vector.h" 1
# 41 "../../../src/systemc/utils/sc_vector.h"
extern "C" {
  typedef int (*CFT)( const void*, const void* );
}
# 52 "../../../src/systemc/utils/sc_vector.h"
class sc_pvector_base
{
  public:
    enum {
 default_alloc = 4,
 max_alloc = (1 << 20)
    };

protected:

    typedef void* item_type;

    typedef item_type* iterator;
    typedef const item_type* const_iterator;

    sc_pvector_base( int alloc = default_alloc );
    sc_pvector_base( const sc_pvector_base& );
    ~sc_pvector_base();


    int size() const
 { return m_sz; }


    iterator begin()
        { return m_data; }

    const_iterator begin() const
        { return m_data; }

    iterator end()
        { return m_data + m_sz; }

    const_iterator end() const
        { return m_data + m_sz; }


    sc_pvector_base& operator = ( const sc_pvector_base& );


    void** raw_data()
 { return m_data; }

    void* const* raw_data() const
 { return m_data; }


    void*& operator [] ( int i );
    const void*& operator [] ( int i ) const;

    void*& fetch( int i )
 { return m_data[i]; }

    const void*& fetch( int i ) const
 { return (const void*&) m_data[i]; }


    void push_back( void* item )
    {
 if( m_sz == m_alloc ) {
     resize( m_sz + 11 );
 }
 m_data[m_sz] = item;
 ++ m_sz;
    }


    void erase_all()
        { m_sz = 0; }


    void sort( CFT compar );



    void put( void* new_item, int i )
 { m_data[i] = new_item; }

    void decr_count()
 { m_sz ? m_sz -- : 0; }

    void decr_count( int k )
 { m_sz -= k; if( m_sz < 0 ) m_sz = 0; }

private:

    void resize( int new_sz );

    int m_alloc;
    void** m_data;
    void* m_default_data[default_alloc];
    int m_sz;
};
# 153 "../../../src/systemc/utils/sc_vector.h"
template< class T >
class sc_pvector
: public sc_pvector_base
{
public:

    typedef T* iterator;
    typedef const T* const_iterator;

    sc_pvector( int alloc = sc_pvector_base::default_alloc )
 : sc_pvector_base( alloc )
 {}

    sc_pvector( const sc_pvector<T>& rhs )
 : sc_pvector_base( rhs )
 {}

    ~sc_pvector()
 {}


    int size() const
 { return sc_pvector_base::size(); }


    iterator begin()
        { return (iterator) sc_pvector_base::begin(); }

    const_iterator begin() const
        { return (const_iterator) sc_pvector_base::begin(); }

    iterator end()
        { return (iterator) sc_pvector_base::end(); }

    const_iterator end() const
        { return (const_iterator) sc_pvector_base::end(); }


    sc_pvector<T>& operator = ( const sc_pvector<T>& rhs )
 { return (sc_pvector<T>&) sc_pvector_base::operator = ( rhs ); }


    T& operator [] ( int i )
 { return (T&) sc_pvector_base::operator [] ( i ); }

    const T& operator [] ( int i ) const
 { return (const T&) sc_pvector_base::operator [] ( i ); }

    T& fetch( int i )
 { return (T&) sc_pvector_base::fetch( i ); }

    const T& fetch( int i ) const
 { return (const T&) sc_pvector_base::fetch( i ); }


    T* raw_data()
 { return (T*) sc_pvector_base::raw_data(); }

    const T* raw_data() const
 { return (const T*) sc_pvector_base::raw_data(); }


    void push_back( T item )
 { sc_pvector_base::push_back( (void*) item ); }


    void erase_all()
 { sc_pvector_base::erase_all(); }

    void sort( CFT compar )
 { sc_pvector_base::sort( compar ); }




    void put( T item, int i )
 { sc_pvector_base::put( (void*) item, i ); }

    void decr_count()
 { sc_pvector_base::decr_count(); }

    void decr_count( int k )
 { sc_pvector_base::decr_count( k ); }
};
# 63 "../../../src/systemc/kernel/sc_simcontext.h" 2
# 1 "../../../src/systemc/utils/sc_pq.h" 1
# 41 "../../../src/systemc/utils/sc_pq.h"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 42 "../../../src/systemc/utils/sc_pq.h" 2
# 50 "../../../src/systemc/utils/sc_pq.h"
class sc_ppq_base
{
public:

    typedef int (*compare_fn_t)( const void*, const void* );

    sc_ppq_base( int sz, compare_fn_t cmp );

    ~sc_ppq_base();

    void* top() const
 { return m_heap[1]; }

    void* extract_top();

    void insert( void* elem );

    int size() const
 { return m_heap_size; }

    bool empty() const
 { return (m_heap_size == 0); }

protected:

    int parent( int i ) const
 { return i >> 1; }

    int left( int i ) const
 { return i << 1; }

    int right( int i ) const
 { return (i << 1) + 1; }

    void heapify( int i );

private:

    void** m_heap;
    int m_size_alloc;
    int m_heap_size;
    compare_fn_t m_compar;
};
# 103 "../../../src/systemc/utils/sc_pq.h"
template <class T>
class sc_ppq
    : public sc_ppq_base
{
public:




    sc_ppq( int sz, compare_fn_t cmp )
        : sc_ppq_base( sz, cmp )
 {}

    ~sc_ppq()
 {}


    T top() const
 { return (T) sc_ppq_base::top(); }



    T extract_top()
 { return (T) sc_ppq_base::extract_top(); }



    void insert( T elem )
 { sc_ppq_base::insert( (void*) elem ); }


};
# 64 "../../../src/systemc/kernel/sc_simcontext.h" 2




class sc_cor;
class sc_cor_pkg;
class sc_event;
class sc_event_timed;
class sc_lambda_ptr;
class sc_module;
class sc_module_name;
class sc_module_registry;
class sc_name_gen;
class sc_object;
class sc_object_manager;
class sc_port_registry;
class sc_export_registry;
class sc_prim_channel_registry;
class sc_process_table;
class sc_signal_bool_deval;
class sc_trace_file;
class sc_runnable;
class sc_process_host;



enum sc_curr_proc_kind
{
    SC_NO_PROC_,
    SC_METHOD_PROC_,
    SC_THREAD_PROC_,
    SC_CTHREAD_PROC_
};


struct sc_curr_proc_info
{
    sc_process_b* process_handle;
    sc_curr_proc_kind kind;
    sc_curr_proc_info() : process_handle( 0 ), kind( SC_NO_PROC_ ) {}
};

typedef const sc_curr_proc_info* sc_curr_proc_handle;




const int SC_SIM_OK = 0;
const int SC_SIM_ERROR = 1;
const int SC_SIM_USER_STOP = 2;

enum sc_stop_mode {
    SC_STOP_FINISH_DELTA,
    SC_STOP_IMMEDIATE
};
extern void sc_set_stop_mode( sc_stop_mode mode );
extern sc_stop_mode sc_get_stop_mode();
# 129 "../../../src/systemc/kernel/sc_simcontext.h"
class sc_simcontext
{
    friend class sc_event;
    friend class sc_module;
    friend class sc_object;
    friend class sc_time;
    friend class sc_clock;

    friend bool sc_end_of_simulation_invoked();
    friend bool sc_start_of_simulation_invoked();

    void init();
    void clean();

public:

    sc_simcontext();
    ~sc_simcontext();

    void initialize( bool = false );
    void cycle( const sc_time& );
    void simulate( const sc_time& duration );
    void stop();
    void end();
    void reset();

    int sim_status() const;
 bool elaboration_done() const;

    sc_object_manager* get_object_manager();

    void hierarchy_push( sc_module* );
    sc_module* hierarchy_pop();
    sc_module* hierarchy_curr() const;
    sc_object* first_object();
    sc_object* next_object();
    sc_object* find_object( const char* name );

    sc_module_registry* get_module_registry();
    sc_port_registry* get_port_registry();
    sc_export_registry* get_export_registry();
    sc_prim_channel_registry* get_prim_channel_registry();


    const char* gen_unique_name( const char* basename_ );

    sc_method_handle register_method_process( const char* name,
           SC_ENTRY_FUNC fn,
           sc_module* );
    sc_method_handle create_dynamic_method_process( const char* name,
                 SC_ENTRY_FUNC fn,
                 sc_process_host*,
          bool dont_initialize = false);
    sc_thread_handle register_thread_process( const char* name,
           SC_ENTRY_FUNC fn,
           sc_module* );
    sc_thread_handle create_dynamic_thread_process( const char* name,
                 SC_ENTRY_FUNC fn,
                 sc_process_host*,
                 size_t size = 0,
                 bool dont_initialize = false );
    sc_cthread_handle register_cthread_process( const char* name,
      SC_ENTRY_FUNC fn,
      sc_module* );

    sc_curr_proc_handle get_curr_proc_info();
    void set_curr_proc( sc_method_handle );
    void set_curr_proc( sc_thread_handle );
    void reset_curr_proc();

    int next_proc_id();

    void add_trace_file( sc_trace_file* );

    friend void sc_set_time_resolution( double, sc_time_unit );
    friend sc_time sc_get_time_resolution();
    friend void sc_set_default_time_unit( double, sc_time_unit );
    friend sc_time sc_get_default_time_unit();

    const sc_time& time_stamp() const;

    uint64 delta_count() const;
    bool is_running() const;
    bool update_phase() const;
    bool get_error();
    void set_error();

    sc_cor_pkg* cor_pkg()
        { return m_cor_pkg; }
    sc_cor* next_cor();

    const sc_pvector<sc_object*>& get_child_objects() const;

    void elaborate();
    void prepare_to_simulate();
    inline void initial_crunch( bool no_crunch );

private:

    void add_child_object( sc_object* );
    void remove_child_object( sc_object* );

    void crunch();

    const sc_time next_time();

    int add_delta_event( sc_event* );
    void remove_delta_event( sc_event* );
    void add_timed_event( sc_event_timed* );

    void trace_cycle( bool delta_cycle );

    void push_runnable_method( sc_method_handle );
    void push_runnable_thread( sc_thread_handle );

    void push_runnable_method_front( sc_method_handle );
    void push_runnable_thread_front( sc_thread_handle );

    sc_method_handle pop_runnable_method();
    sc_thread_handle pop_runnable_thread();

    void remove_runnable_method( sc_method_handle );
    void remove_runnable_thread( sc_thread_handle );

    void do_sc_stop_action();

    friend void watching( const sc_lambda_ptr&, sc_simcontext* );
    friend void watching( const sc_signal_bool_deval&, sc_simcontext* );

private:

    sc_object_manager* m_object_manager;

    sc_module_registry* m_module_registry;
    sc_port_registry* m_port_registry;
    sc_export_registry* m_export_registry;
    sc_prim_channel_registry* m_prim_channel_registry;

    sc_name_gen* m_name_gen;

    sc_process_table* m_process_table;
    sc_curr_proc_info m_curr_proc_info;
    int m_next_proc_id;

    sc_pvector<sc_object*> m_child_objects;

    sc_pvector<sc_event*> m_delta_events;
    sc_ppq<sc_event_timed*>* m_timed_events;

    sc_pvector<sc_trace_file*> m_trace_files;
    bool m_something_to_trace;

    sc_runnable* m_runnable;

    sc_time_params* m_time_params;
    sc_time m_curr_time;

    uint64 m_delta_count;
    bool m_forced_stop;
    bool m_ready_to_simulate;
    bool m_elaboration_done;
    bool m_update_phase;
    bool m_error;
    bool m_in_simulator_control;
    bool m_end_of_simulation_called;
    bool m_start_of_simulation_called;


    sc_event* m_until_event;

    sc_cor_pkg* m_cor_pkg;
    sc_cor* m_cor;

    void (*m_watching_fn)( const sc_lambda_ptr&, sc_simcontext* );

private:


    sc_simcontext( const sc_simcontext& );
    sc_simcontext& operator = ( const sc_simcontext& );
};




inline
bool
sc_simcontext::elaboration_done() const
{
    return m_elaboration_done;
}


inline
int
sc_simcontext::sim_status() const
{
    if( m_error ) {
        return SC_SIM_ERROR;
    }
    if( m_forced_stop ) {
        return SC_SIM_USER_STOP;
    }
    return SC_SIM_OK;
}


inline
sc_object_manager*
sc_simcontext::get_object_manager()
{
    return m_object_manager;
}

inline
sc_module_registry*
sc_simcontext::get_module_registry()
{
    return m_module_registry;
}

inline
sc_port_registry*
sc_simcontext::get_port_registry()
{
    return m_port_registry;
}

inline
sc_export_registry*
sc_simcontext::get_export_registry()
{
    return m_export_registry;
}

inline
sc_prim_channel_registry*
sc_simcontext::get_prim_channel_registry()
{
    return m_prim_channel_registry;
}


inline
sc_curr_proc_handle
sc_simcontext::get_curr_proc_info()
{
    return &m_curr_proc_info;
}


inline
int
sc_simcontext::next_proc_id()
{
    return ( ++ m_next_proc_id );
}


inline
const sc_time&
sc_simcontext::time_stamp() const
{
    return m_curr_time;
}


inline
uint64
sc_simcontext::delta_count() const
{
    return m_delta_count;
}

inline
bool
sc_simcontext::is_running() const
{
    return m_ready_to_simulate;
}

inline
bool
sc_simcontext::update_phase() const
{
    return m_update_phase;
}

inline
void
sc_simcontext::set_error()
{
    m_error = true;
}


inline
bool
sc_simcontext::get_error()
{
    return m_error;
}

inline
int
sc_simcontext::add_delta_event( sc_event* e )
{
    m_delta_events.push_back( e );
    return ( m_delta_events.size() - 1 );
}

inline
void
sc_simcontext::add_timed_event( sc_event_timed* et )
{
    m_timed_events->insert( et );
}



extern sc_simcontext* sc_get_curr_simcontext();

inline
sc_process_b*
sc_get_curr_process_handle()
{
    return sc_get_curr_simcontext()->get_curr_proc_info()->process_handle;
}

inline
sc_curr_proc_kind
sc_get_curr_process_kind()
{
    return sc_get_curr_simcontext()->get_curr_proc_info()->kind;
}

extern sc_process_b* sc_get_last_created_process_handle();


extern
const char*
sc_gen_unique_name( const char* basename_ );



extern
void
sc_set_random_seed( unsigned int seed_ );


extern void sc_start( const sc_time& duration );
extern void sc_start( double duration = -1 );
extern void sc_stop();

extern void sc_initialize();
extern void sc_cycle( const sc_time& duration );

extern uint64 sc_delta_count();
extern const sc_time& sc_time_stamp();
extern double sc_simulation_time();

inline
void
sc_start( double duration, sc_time_unit time_unit )
{
    sc_start( sc_time( duration, time_unit ) );
}

inline
void
sc_cycle( double duration, sc_time_unit time_unit )
{
    sc_cycle( sc_time( duration, time_unit ) );
}


inline
void
sc_cycle( double duration )
{
    sc_cycle( sc_time( duration, true ) );
}

inline
bool
sc_end_of_simulation_invoked()
{
        return sc_get_curr_simcontext()->m_end_of_simulation_called;
}


inline
bool
sc_start_of_simulation_invoked()
{
        return sc_get_curr_simcontext()->m_start_of_simulation_called;
}
# 67 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/kernel/sc_ver.h" 1
# 40 "../../../src/systemc/kernel/sc_ver.h"
extern const char* sc_copyright();
extern const char* sc_release();
extern const char* sc_version();
# 58 "../../../src/systemc/kernel/sc_ver.h"
class sc_api_version_2_1_0 {
  public:
 sc_api_version_2_1_0 ();
};


static sc_api_version_2_1_0 api_version_check;
# 68 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/bit/sc_bit.h" 1
# 40 "../../../src/systemc/datatypes/bit/sc_bit.h"
# 1 "../../../src/systemc/utils/sc_iostream.h" 1
# 41 "../../../src/systemc/datatypes/bit/sc_bit.h" 2


namespace sc_dt
{


class sc_bit;


class sc_logic;
# 60 "../../../src/systemc/datatypes/bit/sc_bit.h"
class sc_bit
{


    static void invalid_value( char );
    static void invalid_value( int );

    static bool to_value( char c )
 {
     if( c != '0' && c != '1' ) {
  invalid_value( c );
     }
     return ( c == '0' ? false : true );
 }

    static bool to_value( int i )
 {
     if( i != 0 && i != 1 ) {
  invalid_value( i );
     }
     return ( i == 0 ? false : true );
 }

public:




    sc_bit()
 : m_val( false )
 {}

    explicit sc_bit( unsigned long long a )
 : m_val( a )
 {}

    explicit sc_bit( bool a )
 : m_val( a )
 {}

    explicit sc_bit( int a )
 : m_val( to_value( a ) )
 {}

    explicit sc_bit( char a )
 : m_val( to_value( a ) )
 {}

    explicit sc_bit( const sc_logic& a );





    sc_bit( const sc_bit& a )
 : m_val( a.m_val )
 {}





    ~sc_bit()
 {}





    sc_bit& operator = ( const sc_bit& b )
 { m_val = b.m_val; return *this; }

    sc_bit& operator = ( long long b )
 { return ( *this = sc_bit( (int)b ) ); }

    sc_bit& operator = ( unsigned long long b )
 { return ( *this = sc_bit( (int)b ) ); }

    sc_bit& operator = ( long b )
 { return ( *this = sc_bit( (int)b ) ); }

    sc_bit& operator = ( unsigned long b )
 { return ( *this = sc_bit( (int)b ) ); }

    sc_bit& operator = ( int b )
 { return ( *this = sc_bit( b ) ); }

    sc_bit& operator = ( bool b )
 { return ( *this = sc_bit( b ) ); }

    sc_bit& operator = ( char b )
 { return ( *this = sc_bit( b ) ); }

    sc_bit& operator = ( const sc_logic& b );




    sc_bit& operator &= ( const sc_bit& b )
 { m_val = ( m_val && b.m_val ); return *this; }

    sc_bit& operator &= ( int b )
 { return ( *this &= sc_bit( b ) ); }

    sc_bit& operator &= ( bool b )
 { return ( *this &= sc_bit( b ) ); }

    sc_bit& operator &= ( char b )
 { return ( *this &= sc_bit( b ) ); }


    sc_bit& operator |= ( const sc_bit& b )
 { m_val = ( m_val || b.m_val ); return *this; }

    sc_bit& operator |= ( int b )
 { return ( *this |= sc_bit( b ) ); }

    sc_bit& operator |= ( bool b )
 { return ( *this |= sc_bit( b ) ); }

    sc_bit& operator |= ( char b )
 { return ( *this |= sc_bit( b ) ); }


    sc_bit& operator ^= ( const sc_bit& b )
 { m_val = ( m_val != b.m_val ); return *this; }

    sc_bit& operator ^= ( int b )
 { return ( *this ^= sc_bit( b ) ); }

    sc_bit& operator ^= ( bool b )
 { return ( *this ^= sc_bit( b ) ); }

    sc_bit& operator ^= ( char b )
 { return ( *this ^= sc_bit( b ) ); }







    operator bool () const
 { return m_val; }

    bool operator ! () const
 { return ! m_val; }




    bool to_bool() const
 { return m_val; }

    char to_char() const
 { return ( m_val ? '1' : '0' ); }






    friend bool operator == ( const sc_bit& a, const sc_bit& b )
        { return ( a.m_val == b.m_val ); }

    friend bool operator == ( const sc_bit& a, int b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( const sc_bit& a, bool b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( const sc_bit& a, char b )
        { return ( a == sc_bit( b ) ); }

    friend bool operator == ( int a, const sc_bit& b )
 { return ( sc_bit( a ) == b ); }

    friend bool operator == ( bool a, const sc_bit& b )
 { return ( sc_bit( a ) == b ); }

    friend bool operator == ( char a, const sc_bit& b )
 { return ( sc_bit( a ) == b ); }



    friend bool equal( const sc_bit& a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, int b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, bool b )
        { return ( a == b ); }

    friend bool equal( const sc_bit& a, char b )
        { return ( a == b ); }

    friend bool equal( int a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( bool a, const sc_bit& b )
        { return ( a == b ); }

    friend bool equal( char a, const sc_bit& b )
        { return ( a == b ); }



    friend bool operator != ( const sc_bit& a, const sc_bit& b )
        { return ( a.m_val != b.m_val ); }

    friend bool operator != ( const sc_bit& a, int b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( const sc_bit& a, bool b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( const sc_bit& a, char b )
        { return ( a != sc_bit( b ) ); }

    friend bool operator != ( int a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }

    friend bool operator != ( bool a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }

    friend bool operator != ( char a, const sc_bit& b )
        { return ( sc_bit( a ) != b ); }



    friend bool not_equal( const sc_bit& a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, int b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, bool b )
        { return ( a != b ); }

    friend bool not_equal( const sc_bit& a, char b )
        { return ( a != b ); }

    friend bool not_equal( int a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( bool a, const sc_bit& b )
        { return ( a != b ); }

    friend bool not_equal( char a, const sc_bit& b )
        { return ( a != b ); }
# 319 "../../../src/systemc/datatypes/bit/sc_bit.h"
    friend const sc_bit operator ~ ( const sc_bit& a )
        { return sc_bit( ! a.m_val ); }



    sc_bit& b_not()
        { m_val = ( ! m_val ); return *this; }



    friend const sc_bit b_not( const sc_bit& a )
        { return ( ~ a ); }



    friend void b_not( sc_bit& r, const sc_bit& a )
        { r = ( ~ a ); }






    friend const sc_bit operator | ( const sc_bit& a, const sc_bit& b )
        { return sc_bit( a.m_val || b.m_val ); }

    friend const sc_bit operator | ( const sc_bit& a, int b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( const sc_bit& a, bool b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( const sc_bit& a, char b )
        { return ( a | sc_bit( b ) ); }

    friend const sc_bit operator | ( int a, const sc_bit& b )
 { return ( sc_bit( a ) | b ); }

    friend const sc_bit operator | ( bool a, const sc_bit& b )
 { return ( sc_bit( a ) | b ); }

    friend const sc_bit operator | ( char a, const sc_bit& b )
 { return ( sc_bit( a ) | b ); }



    friend const sc_bit b_or( const sc_bit& a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, int b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, bool b )
        { return ( a | b ); }

    friend const sc_bit b_or( const sc_bit& a, char b )
        { return ( a | b ); }

    friend const sc_bit b_or( int a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( bool a, const sc_bit& b )
        { return ( a | b ); }

    friend const sc_bit b_or( char a, const sc_bit& b )
        { return ( a | b ); }



    friend void b_or( sc_bit& r, const sc_bit& a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, int b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, bool b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, const sc_bit& a, char b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, int a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, bool a, const sc_bit& b )
        { r = ( a | b ); }

    friend void b_or( sc_bit& r, char a, const sc_bit& b )
        { r = ( a | b ); }






    friend const sc_bit operator & ( const sc_bit& a, const sc_bit& b )
 { return sc_bit( a.m_val && b.m_val ); }

    friend const sc_bit operator & ( const sc_bit& a, int b )
 { return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( const sc_bit& a, bool b )
 { return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( const sc_bit& a, char b )
 { return ( a & sc_bit( b ) ); }

    friend const sc_bit operator & ( int a, const sc_bit& b )
 { return ( sc_bit( a ) & b ); }

    friend const sc_bit operator & ( bool a, const sc_bit& b )
 { return ( sc_bit( a ) & b ); }

    friend const sc_bit operator & ( char a, const sc_bit& b )
 { return ( sc_bit( a ) & b ); }



    friend const sc_bit b_and( const sc_bit& a, const sc_bit& b )
 { return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, int b )
 { return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, bool b )
 { return ( a & b ); }

    friend const sc_bit b_and( const sc_bit& a, char b )
 { return ( a & b ); }

    friend const sc_bit b_and( int a, const sc_bit& b )
 { return ( a & b ); }

    friend const sc_bit b_and( bool a, const sc_bit& b )
 { return ( a & b ); }

    friend const sc_bit b_and( char a, const sc_bit& b )
 { return ( a & b ); }



    friend void b_and( sc_bit& r, const sc_bit& a, const sc_bit& b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, int b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, bool b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, const sc_bit& a, char b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, int a, const sc_bit& b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, bool a, const sc_bit& b )
 { r = ( a & b ); }

    friend void b_and( sc_bit& r, char a, const sc_bit& b )
 { r = ( a & b ); }






    friend const sc_bit operator ^ ( const sc_bit& a, const sc_bit& b )
 { return sc_bit( a.m_val != b.m_val ); }

    friend const sc_bit operator ^ ( const sc_bit& a, int b )
 { return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( const sc_bit& a, bool b )
 { return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( const sc_bit& a, char b )
 { return ( a ^ sc_bit( b ) ); }

    friend const sc_bit operator ^ ( int a, const sc_bit& b )
 { return ( sc_bit( a ) ^ b ); }

    friend const sc_bit operator ^ ( bool a, const sc_bit& b )
 { return ( sc_bit( a ) ^ b ); }

    friend const sc_bit operator ^ ( char a, const sc_bit& b )
 { return ( sc_bit( a ) ^ b ); }



    friend const sc_bit b_xor( const sc_bit& a, const sc_bit& b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, int b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, bool b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( const sc_bit& a, char b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( int a, const sc_bit& b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( bool a, const sc_bit& b )
 { return ( a ^ b ); }

    friend const sc_bit b_xor( char a, const sc_bit& b )
 { return ( a ^ b ); }



    friend void b_xor( sc_bit& r, const sc_bit& a, const sc_bit& b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, int b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, bool b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, const sc_bit& a, char b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, int a, const sc_bit& b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, bool a, const sc_bit& b )
 { r = ( a ^ b ); }

    friend void b_xor( sc_bit& r, char a, const sc_bit& b )
 { r = ( a ^ b ); }




    void print( ostream& os = cout ) const
 { os << to_bool(); }

    void scan( istream& = cin );

private:

    bool m_val;
};




inline
ostream&
operator << ( ostream& os, const sc_bit& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_bit& a )
{
    a.scan( is );
    return is;
}

}
# 69 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/bit/sc_logic.h" 1
# 44 "../../../src/systemc/datatypes/bit/sc_logic.h"
# 1 "../../../src/systemc/kernel/sc_macros.h" 1
# 40 "../../../src/systemc/kernel/sc_macros.h"
template <class T>
inline
const T
sc_min( const T& a, const T& b )
{
    return ( ( a <= b ) ? a : b );
}

template <class T>
inline
const T
sc_max( const T& a, const T& b )
{
    return ( ( a >= b ) ? a : b );
}

template <class T>
inline
const T
sc_abs( const T& a )
{




    T z( a );
    z = 0;
    if( a >= z ) {
 return a;
    } else {
 T c( a );
 c = -a;
 return c;
    }
}
# 45 "../../../src/systemc/datatypes/bit/sc_logic.h" 2
# 1 "../../../src/systemc/utils/sc_mempool.h" 1
# 49 "../../../src/systemc/utils/sc_mempool.h"
class sc_mempool
{
public:

    static void* allocate( size_t sz );
    static void release( void* p, size_t sz );
    static void display_statistics();
};
# 65 "../../../src/systemc/utils/sc_mempool.h"
class sc_mpobject
{
public:

    static void* operator new( size_t sz )
 { return sc_mempool::allocate( sz ); }

    static void operator delete( void* p, size_t sz )
 { sc_mempool::release( p, sz ); }

    static void* operator new[]( size_t sz )
 { return sc_mempool::allocate( sz ); }

    static void operator delete[]( void* p, size_t sz )
 { sc_mempool::release( p, sz ); }
};
# 46 "../../../src/systemc/datatypes/bit/sc_logic.h" 2
# 1 "../../../src/systemc/datatypes/bit/sc_bit.h" 1
# 47 "../../../src/systemc/datatypes/bit/sc_logic.h" 2


namespace sc_dt
{


class sc_logic;
# 62 "../../../src/systemc/datatypes/bit/sc_logic.h"
enum sc_logic_value_t
{
    Log_0 = 0,
    Log_1,
    Log_Z,
    Log_X
};
# 77 "../../../src/systemc/datatypes/bit/sc_logic.h"
class sc_logic
{
    friend class sc_logic_resolve;

private:



    static void invalid_value( sc_logic_value_t );
    static void invalid_value( char );
    static void invalid_value( int );

    static sc_logic_value_t to_value( sc_logic_value_t v )
 {
     if( v < Log_0 || v > Log_X ) {
  invalid_value( v );
     }
     return v;
 }

    static sc_logic_value_t to_value( bool b )
 { return ( b ? Log_1 : Log_0 ); }

    static sc_logic_value_t to_value( char c )
 {
     sc_logic_value_t v = char_to_logic[(int)c];
     if( v < Log_0 || v > Log_X ) {
  invalid_value( c );
     }
     return v;
 }

    static sc_logic_value_t to_value( int i )
 {
     if( i < 0 || i > 3 ) {
  invalid_value( i );
     }
     return sc_logic_value_t( i );
 }


    void invalid_01() const;

public:



    static const sc_logic_value_t char_to_logic[128];
    static const char logic_to_char[4];
    static const sc_logic_value_t and_table[4][4];
    static const sc_logic_value_t or_table[4][4];
    static const sc_logic_value_t xor_table[4][4];
    static const sc_logic_value_t not_table[4];




    sc_logic()
 : m_val( Log_X )
 {}

    sc_logic( const sc_logic& a )
 : m_val( a.m_val )
 {}

    sc_logic( sc_logic_value_t v )
 : m_val( to_value( v ) )
 {}

    explicit sc_logic( bool a )
 : m_val( to_value( a ) )
 {}

    explicit sc_logic( char a )
 : m_val( to_value( a ) )
 {}

    explicit sc_logic( int a )
 : m_val( to_value( a ) )
 {}

    explicit sc_logic( const sc_bit& a )
 : m_val( to_value( a.to_bool() ) )
 {}




    ~sc_logic()
 {}




    sc_logic& operator = ( const sc_logic& a )
 { m_val = a.m_val; return *this; }

    sc_logic& operator = ( sc_logic_value_t v )
 { *this = sc_logic( v ); return *this; }

    sc_logic& operator = ( bool a )
 { *this = sc_logic( a ); return *this; }

    sc_logic& operator = ( char a )
 { *this = sc_logic( a ); return *this; }

    sc_logic& operator = ( int a )
 { *this = sc_logic( a ); return *this; }

    sc_logic& operator = ( const sc_bit& a )
 { *this = sc_logic( a ); return *this; }




    sc_logic& operator &= ( const sc_logic& b )
 { m_val = and_table[m_val][b.m_val]; return *this; }

    sc_logic& operator &= ( sc_logic_value_t v )
 { *this &= sc_logic( v ); return *this; }

    sc_logic& operator &= ( bool b )
 { *this &= sc_logic( b ); return *this; }

    sc_logic& operator &= ( char b )
 { *this &= sc_logic( b ); return *this; }

    sc_logic& operator &= ( int b )
 { *this &= sc_logic( b ); return *this; }


    sc_logic& operator |= ( const sc_logic& b )
        { m_val = or_table[m_val][b.m_val]; return *this; }

    sc_logic& operator |= ( sc_logic_value_t v )
 { *this |= sc_logic( v ); return *this; }

    sc_logic& operator |= ( bool b )
 { *this |= sc_logic( b ); return *this; }

    sc_logic& operator |= ( char b )
 { *this |= sc_logic( b ); return *this; }

    sc_logic& operator |= ( int b )
 { *this |= sc_logic( b ); return *this; }


    sc_logic& operator ^= ( const sc_logic& b )
        { m_val = xor_table[m_val][b.m_val]; return *this; }

    sc_logic& operator ^= ( sc_logic_value_t v )
 { *this ^= sc_logic( v ); return *this; }

    sc_logic& operator ^= ( bool b )
 { *this ^= sc_logic( b ); return *this; }

    sc_logic& operator ^= ( char b )
 { *this ^= sc_logic( b ); return *this; }

    sc_logic& operator ^= ( int b )
 { *this ^= sc_logic( b ); return *this; }






    const sc_logic operator ~ () const
 { return sc_logic( not_table[m_val] ); }

    sc_logic& b_not()
 { m_val = not_table[m_val]; return *this; }




    friend const sc_logic operator & ( const sc_logic& a, const sc_logic& b )
 { return sc_logic( and_table[a.m_val][b.m_val] ); }

    friend const sc_logic operator & ( const sc_logic& a, sc_logic_value_t b )
 { return ( a & sc_logic( b ) ); }

    friend const sc_logic operator & ( const sc_logic& a, bool b )
 { return ( a & sc_logic( b ) ); }

    friend const sc_logic operator & ( const sc_logic& a, char b )
 { return ( a & sc_logic( b ) ); }

    friend const sc_logic operator & ( const sc_logic& a, int b )
 { return ( a & sc_logic( b ) ); }

    friend const sc_logic operator & ( sc_logic_value_t a, const sc_logic& b )
 { return ( sc_logic( a ) & b ); }

    friend const sc_logic operator & ( bool a, const sc_logic& b )
 { return ( sc_logic( a ) & b ); }

    friend const sc_logic operator & ( char a, const sc_logic& b )
 { return ( sc_logic( a ) & b ); }

    friend const sc_logic operator & ( int a, const sc_logic& b )
 { return ( sc_logic( a ) & b ); }




    friend const sc_logic operator | ( const sc_logic& a, const sc_logic& b )
 { return sc_logic( or_table[a.m_val][b.m_val] ); }

    friend const sc_logic operator | ( const sc_logic& a, sc_logic_value_t b )
 { return ( a | sc_logic( b ) ); }

    friend const sc_logic operator | ( const sc_logic& a, bool b )
 { return ( a | sc_logic( b ) ); }

    friend const sc_logic operator | ( const sc_logic& a, char b )
 { return ( a | sc_logic( b ) ); }

    friend const sc_logic operator | ( const sc_logic& a, int b )
 { return ( a | sc_logic( b ) ); }

    friend const sc_logic operator | ( sc_logic_value_t a, const sc_logic& b )
 { return ( sc_logic( a ) | b ); }

    friend const sc_logic operator | ( bool a, const sc_logic& b )
 { return ( sc_logic( a ) | b ); }

    friend const sc_logic operator | ( char a, const sc_logic& b )
 { return ( sc_logic( a ) | b ); }

    friend const sc_logic operator | ( int a, const sc_logic& b )
 { return ( sc_logic( a ) | b ); }




    friend const sc_logic operator ^ ( const sc_logic& a, const sc_logic& b )
 { return sc_logic( xor_table[a.m_val][b.m_val] ); }

    friend const sc_logic operator ^ ( const sc_logic& a, sc_logic_value_t b )
 { return ( a ^ sc_logic( b ) ); }

    friend const sc_logic operator ^ ( const sc_logic& a, bool b )
 { return ( a ^ sc_logic( b ) ); }

    friend const sc_logic operator ^ ( const sc_logic& a, char b )
 { return ( a ^ sc_logic( b ) ); }

    friend const sc_logic operator ^ ( const sc_logic& a, int b )
 { return ( a ^ sc_logic( b ) ); }

    friend const sc_logic operator ^ ( sc_logic_value_t a, const sc_logic& b )
 { return ( sc_logic( a ) ^ b ); }

    friend const sc_logic operator ^ ( bool a, const sc_logic& b )
 { return ( sc_logic( a ) ^ b ); }

    friend const sc_logic operator ^ ( char a, const sc_logic& b )
 { return ( sc_logic( a ) ^ b ); }

    friend const sc_logic operator ^ ( int a, const sc_logic& b )
 { return ( sc_logic( a ) ^ b ); }




    friend bool operator == ( const sc_logic& a, const sc_logic& b )
 { return ( (int) a.m_val == b.m_val ); }

    friend bool operator == ( const sc_logic& a, sc_logic_value_t b )
 { return ( a == sc_logic( b ) ); }

    friend bool operator == ( const sc_logic& a, bool b )
 { return ( a == sc_logic( b ) ); }

    friend bool operator == ( const sc_logic& a, char b )
 { return ( a == sc_logic( b ) ); }

    friend bool operator == ( const sc_logic& a, int b )
 { return ( a == sc_logic( b ) ); }

    friend bool operator == ( sc_logic_value_t a, const sc_logic& b )
 { return ( sc_logic( a ) == b ); }

    friend bool operator == ( bool a, const sc_logic& b )
 { return ( sc_logic( a ) == b ); }

    friend bool operator == ( char a, const sc_logic& b )
 { return ( sc_logic( a ) == b ); }

    friend bool operator == ( int a, const sc_logic& b )
 { return ( sc_logic( a ) == b ); }


    friend bool operator != ( const sc_logic& a, const sc_logic& b )
 { return ( (int) a.m_val != b.m_val ); }

    friend bool operator != ( const sc_logic& a, sc_logic_value_t b )
 { return ( a != sc_logic( b ) ); }

    friend bool operator != ( const sc_logic& a, bool b )
 { return ( a != sc_logic( b ) ); }

    friend bool operator != ( const sc_logic& a, char b )
 { return ( a != sc_logic( b ) ); }

    friend bool operator != ( const sc_logic& a, int b )
 { return ( a != sc_logic( b ) ); }

    friend bool operator != ( sc_logic_value_t a, const sc_logic& b )
 { return ( sc_logic( a ) != b ); }

    friend bool operator != ( bool a, const sc_logic& b )
 { return ( sc_logic( a ) != b ); }

    friend bool operator != ( char a, const sc_logic& b )
 { return ( sc_logic( a ) != b ); }

    friend bool operator != ( int a, const sc_logic& b )
 { return ( sc_logic( a ) != b ); }




    sc_logic_value_t value() const
 { return m_val; }


    bool is_01() const
 { return ( (int) m_val == Log_0 || (int) m_val == Log_1 ); }

    bool to_bool() const
 { if( ! is_01() ) { invalid_01(); } return ( (int) m_val != Log_0 ); }

    char to_char() const
 { return logic_to_char[m_val]; }




    void print( ostream& os = cout ) const
 { os << to_char(); }

    void scan( istream& is = cin );




    static void* operator new( size_t, void* p )
 { return p; }

    static void* operator new( size_t sz )
 { return sc_mempool::allocate( sz ); }

    static void operator delete( void* p, size_t sz )
 { sc_mempool::release( p, sz ); }

    static void* operator new [] ( size_t sz )
 { return sc_mempool::allocate( sz ); }

    static void operator delete [] ( void* p, size_t sz )
 { sc_mempool::release( p, sz ); }

private:

    sc_logic_value_t m_val;

private:


    explicit sc_logic( const char* );
    sc_logic& operator = ( const char* );
};




inline
ostream&
operator << ( ostream& os, const sc_logic& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_logic& a )
{
    a.scan( is );
    return is;
}


extern const sc_logic SC_LOGIC_0;
extern const sc_logic SC_LOGIC_1;
extern const sc_logic SC_LOGIC_Z;
extern const sc_logic SC_LOGIC_X;


extern const sc_logic sc_logic_0;
extern const sc_logic sc_logic_1;
extern const sc_logic sc_logic_Z;
extern const sc_logic sc_logic_X;


}
# 70 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/bit/sc_lv_base.h" 1
# 43 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
# 1 "../../../src/systemc/datatypes/bit/sc_bit_ids.h" 1
# 44 "../../../src/systemc/datatypes/bit/sc_lv_base.h" 2
# 1 "../../../src/systemc/datatypes/bit/sc_bv_base.h" 1
# 41 "../../../src/systemc/datatypes/bit/sc_bv_base.h"
# 1 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h" 1
# 41 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
# 1 "../../../src/systemc/datatypes/bit/sc_proxy.h" 1
# 48 "../../../src/systemc/datatypes/bit/sc_proxy.h"
# 1 "../../../src/systemc/kernel/sc_cmnhdr.h" 1
# 49 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2

# 1 "../../../src/systemc/datatypes/int/sc_signed.h" 1
# 71 "../../../src/systemc/datatypes/int/sc_signed.h"
# 1 "../../../src/systemc/kernel/sc_object.h" 1
# 44 "../../../src/systemc/kernel/sc_object.h"
# 1 "../../../src/systemc/kernel/sc_attribute.h" 1
# 49 "../../../src/systemc/kernel/sc_attribute.h"
class sc_attr_base
{
public:


    sc_attr_base( const sc_string& name_ );
    sc_attr_base( const sc_attr_base& );


    virtual ~sc_attr_base();


    const sc_string& name() const;

private:

    sc_string m_name;

private:


    sc_attr_base();
    sc_attr_base& operator = ( const sc_attr_base& );
};
# 82 "../../../src/systemc/kernel/sc_attribute.h"
class sc_attr_cltn
{
public:


    typedef sc_attr_base* elem_type;
    typedef elem_type* iterator;
    typedef const elem_type* const_iterator;


    sc_attr_cltn();
    sc_attr_cltn( const sc_attr_cltn& );


    ~sc_attr_cltn();




    bool push_back( sc_attr_base* );



          sc_attr_base* operator [] ( const sc_string& name_ );
    const sc_attr_base* operator [] ( const sc_string& name_ ) const;



    sc_attr_base* remove( const sc_string& name_ );


    void remove_all();


    int size() const
        { return m_cltn.size(); }


    iterator begin()
        { return m_cltn.begin(); }
    const_iterator begin() const
        { return m_cltn.begin(); }


    iterator end()
        { return m_cltn.end(); }
    const_iterator end() const
        { return m_cltn.end(); }

private:

    sc_pvector<sc_attr_base*> m_cltn;

private:


    sc_attr_cltn& operator = ( const sc_attr_cltn& );
};
# 149 "../../../src/systemc/kernel/sc_attribute.h"
template <class T>
class sc_attribute
: public sc_attr_base
{
public:



    sc_attribute( const sc_string& name_ )
        : sc_attr_base( name_ ), value()
        {}

    sc_attribute( const sc_string& name_, const T& value_ )
        : sc_attr_base( name_ ), value( value_ )
        {}

    sc_attribute( const sc_attribute<T>& a )
        : sc_attr_base( a.name() ), value( a.value )
        {}




    virtual ~sc_attribute()
        {}

public:


    T value;

private:


    sc_attribute();
    sc_attribute<T>& operator = ( const sc_attribute<T>& );
};
# 45 "../../../src/systemc/kernel/sc_object.h" 2

class sc_trace_file;
class sc_simcontext;
# 56 "../../../src/systemc/kernel/sc_object.h"
class sc_object
{
    friend class sc_object_manager;
 friend class sc_process_b;

public:

    const char* name() const
        { return m_name; }
    const char* basename() const;

    void print() const;
    virtual void print(ostream& os) const;


    void dump() const;
    virtual void dump(ostream& os) const;

    virtual void trace( sc_trace_file* tf ) const;

    virtual const char* kind() const { return "sc_object"; }

    sc_simcontext* simcontext() const
        { return m_simc; }


    bool add_attribute( sc_attr_base& );


          sc_attr_base* get_attribute( const sc_string& name_ );
    const sc_attr_base* get_attribute( const sc_string& name_ ) const;


    sc_attr_base* remove_attribute( const sc_string& name_ );


    void remove_all_attributes();


    int num_attributes() const;


          sc_attr_cltn& attr_cltn();
    const sc_attr_cltn& attr_cltn() const;

    sc_object* get_parent() const { return m_parent; }

protected:

    sc_object();
    sc_object(const char* nm);
    virtual ~sc_object();

private:

    void sc_object_init(const char* nm);

private:


    sc_simcontext* m_simc;
    char* m_ptr;
    char* m_name;
    mutable sc_attr_cltn* m_attr_cltn_p;
    sc_object* m_parent;
};




extern const char SC_HIERARCHY_CHAR;
extern bool sc_enable_name_checking;
# 72 "../../../src/systemc/datatypes/int/sc_signed.h" 2
# 1 "../../../src/systemc/datatypes/misc/sc_value_base.h" 1
# 40 "../../../src/systemc/datatypes/misc/sc_value_base.h"
# 1 "../../../src/systemc/datatypes/int/sc_nbdefs.h" 1
# 41 "../../../src/systemc/datatypes/misc/sc_value_base.h" 2

namespace sc_dt
{

class sc_signed;
class sc_unsigned;
# 57 "../../../src/systemc/datatypes/misc/sc_value_base.h"
class sc_value_base
{
  public:
 virtual void concat_clear_data( bool to_ones=false );
 virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
 virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
 virtual uint64 concat_get_uint64() const;
 virtual int concat_length(bool* xz_present_p=0) const;
 virtual void concat_set( int64 src, int low_i );
 virtual void concat_set( const sc_signed& src, int low_i );
 virtual void concat_set( const sc_unsigned& src, int low_i );
 virtual void concat_set( uint64 src, int low_i );
};

}
using sc_dt::sc_value_base;
# 73 "../../../src/systemc/datatypes/int/sc_signed.h" 2

# 1 "../../../src/systemc/datatypes/int/sc_length_param.h" 1
# 40 "../../../src/systemc/datatypes/int/sc_length_param.h"
# 1 "../../../src/systemc/datatypes/fx/sc_context.h" 1
# 41 "../../../src/systemc/datatypes/fx/sc_context.h"
# 1 "../../../src/systemc/kernel/sc_simcontext.h" 1
# 42 "../../../src/systemc/datatypes/fx/sc_context.h" 2
# 1 "../../../src/systemc/utils/sc_hash.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_context.h" 2


class sc_process_b;


namespace sc_dt
{


class sc_without_context;
template <class T> class sc_global;
template <class T> class sc_context;
# 63 "../../../src/systemc/datatypes/fx/sc_context.h"
class sc_without_context {};
# 72 "../../../src/systemc/datatypes/fx/sc_context.h"
template <class T>
class sc_global
{

    sc_global();

    void update();

public:

    static sc_global<T>* instance();

    const T*& value_ptr();

private:

    static sc_global<T>* m_instance;

    sc_phash<const sc_process_b*,const T*> m_map;
    const sc_process_b* m_proc;
    const T* m_value_ptr;

};
# 103 "../../../src/systemc/datatypes/fx/sc_context.h"
enum sc_context_begin
{
    SC_NOW,
    SC_LATER
};
# 116 "../../../src/systemc/datatypes/fx/sc_context.h"
template <class T>
class sc_context
{
    sc_context( const sc_context<T>& );
    void* operator new( size_t );

public:

    explicit sc_context( const T&, sc_context_begin = SC_NOW );
    ~sc_context();

    void begin();
    void end();

    static const T& default_value();
    const T& value() const;

private:

    const T m_value;
    const T*& m_def_value_ptr;
    const T* m_old_value_ptr;
};
# 149 "../../../src/systemc/datatypes/fx/sc_context.h"
template <class T>
sc_global<T>* sc_global<T>::m_instance = 0;


template <class T>
inline
sc_global<T>::sc_global()
: m_proc( reinterpret_cast<const sc_process_b*>( -1 ) ), m_value_ptr( 0 )
{}


template <class T>
inline
void
sc_global<T>::update()
{
    const sc_process_b* p = sc_get_curr_process_handle();
    if( p != m_proc )
    {
        const T* vp = m_map[p];
        if( vp == 0 )
        {
            vp = new T( sc_without_context() );
            m_map.insert( p, vp );
        }
        m_proc = p;
        m_value_ptr = vp;
    }
}


template <class T>
inline
sc_global<T>*
sc_global<T>::instance()
{
    if( m_instance == 0 )
    {
        m_instance = new sc_global<T>;
    }
    return m_instance;
}


template <class T>
inline
const T*&
sc_global<T>::value_ptr()
{
    update();
    return m_value_ptr;
}
# 209 "../../../src/systemc/datatypes/fx/sc_context.h"
template <class T>
inline
sc_context<T>::sc_context( const sc_context<T>& )
: m_value(),
  m_def_value_ptr( sc_global<T>::instance()->value_ptr() ),
  m_old_value_ptr( 0 )
{

    sc_report_handler::report( SC_FATAL, SC_ID_INTERNAL_ERROR_, "should never be called", "../../../src/systemc/datatypes/fx/sc_context.h", 217 );
}

template <class T>
inline
void*
sc_context<T>::operator new( size_t )
{

    sc_report_handler::report( SC_FATAL, SC_ID_INTERNAL_ERROR_, "should never be called", "../../../src/systemc/datatypes/fx/sc_context.h", 226 );
}


template <class T>
inline
sc_context<T>::sc_context( const T& value_, sc_context_begin begin )
: m_value( value_ ),
  m_def_value_ptr( sc_global<T>::instance()->value_ptr() ),
  m_old_value_ptr( 0 )
{
    if( begin == SC_NOW )
    {
 m_old_value_ptr = m_def_value_ptr;
 m_def_value_ptr = &m_value;
    }
}

template <class T>
inline
sc_context<T>::~sc_context()
{
    if( m_old_value_ptr != 0 )
    {
        m_def_value_ptr = m_old_value_ptr;
 m_old_value_ptr = 0;
    }
}


template <class T>
inline
void
sc_context<T>::begin()
{
    if( m_old_value_ptr == 0 )
    {
 m_old_value_ptr = m_def_value_ptr;
 m_def_value_ptr = &m_value;
    }
    else
    {
        sc_report_handler::report( SC_ERROR, SC_ID_CONTEXT_BEGIN_FAILED_, 0, "../../../src/systemc/datatypes/fx/sc_context.h", 268 );
    }
}

template <class T>
inline
void
sc_context<T>::end()
{
    if( m_old_value_ptr != 0 )
    {
        m_def_value_ptr = m_old_value_ptr;
 m_old_value_ptr = 0;
    }
    else
    {
        sc_report_handler::report( SC_ERROR, SC_ID_CONTEXT_END_FAILED_, 0, "../../../src/systemc/datatypes/fx/sc_context.h", 284 );
    }
}


template <class T>
inline
const T&
sc_context<T>::default_value()
{
    return *sc_global<T>::instance()->value_ptr();
}

template <class T>
inline
const T&
sc_context<T>::value() const
{
    return m_value;
}

}
# 41 "../../../src/systemc/datatypes/int/sc_length_param.h" 2


namespace sc_dt
{


class sc_length_param;
# 56 "../../../src/systemc/datatypes/int/sc_length_param.h"
class sc_length_param
{
public:

             sc_length_param();
             sc_length_param( int );
             sc_length_param( const sc_length_param& );
    explicit sc_length_param( sc_without_context );

    sc_length_param& operator = ( const sc_length_param& );

    friend bool operator == ( const sc_length_param&,
                              const sc_length_param& );
    friend bool operator != ( const sc_length_param&,
         const sc_length_param& );

    int len() const;
    void len( int );

    const sc_string to_string() const;

    void print( ostream& = cout ) const;
    void dump( ostream& = cout ) const;

private:

    int m_len;
};
# 92 "../../../src/systemc/datatypes/int/sc_length_param.h"
typedef sc_context<sc_length_param> sc_length_context;




inline
sc_length_param::sc_length_param()
{
    *this = sc_length_context::default_value();
}

inline
sc_length_param::sc_length_param( int len_ )
{
    { if( (len_) <= 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_WL_, 0, "../../../src/systemc/datatypes/int/sc_length_param.h", 106 ); };
    m_len = len_;
}

inline
sc_length_param::sc_length_param( const sc_length_param& a )
    : m_len( a.m_len )
{}

inline
sc_length_param::sc_length_param( sc_without_context )
    : m_len( SC_DEFAULT_WL_ )
{}


inline
sc_length_param&
sc_length_param::operator = ( const sc_length_param& a )
{
    if( &a != this )
    {
 m_len = a.m_len;
    }
    return *this;
}


inline
bool
operator == ( const sc_length_param& a, const sc_length_param& b )
{
    return ( a.m_len == b.m_len );
}

inline
bool
operator != ( const sc_length_param& a, const sc_length_param& b )
{
    return ( a.m_len != b.m_len );
}


inline
int
sc_length_param::len() const
{
    return m_len;
}

inline
void
sc_length_param::len( int len_ )
{
    { if( (len_) <= 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_WL_, 0, "../../../src/systemc/datatypes/int/sc_length_param.h", 159 ); };
    m_len = len_;
}


inline
ostream&
operator << ( ostream& os, const sc_length_param& a )
{
    a.print( os );
    return os;
}

}
# 75 "../../../src/systemc/datatypes/int/sc_signed.h" 2

# 1 "../../../src/systemc/datatypes/int/sc_nbutils.h" 1
# 77 "../../../src/systemc/datatypes/int/sc_signed.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_nbexterns.h" 1
# 51 "../../../src/systemc/datatypes/int/sc_nbexterns.h"
namespace sc_dt
{

extern
void add_on_help(small_type &us,
                 int unb, int und, unsigned long *ud,
                 small_type vs,
                 int vnb, int vnd, const unsigned long *vd);

extern
void mul_on_help_signed(small_type &us,
                        int unb, int und, unsigned long *ud,
                        int vnb, int vnd, const unsigned long *vd);

void div_on_help_signed(small_type &us,
                        int unb, int und, unsigned long *ud,
                        int vnb, int vnd, const unsigned long *vd);

extern
void mod_on_help_signed(small_type &us,
                        int unb, int und, unsigned long *ud,
                        int vnb, int vnd, const unsigned long *vd);

extern
void mul_on_help_unsigned(small_type &us,
                          int unb, int und, unsigned long *ud,
                          int vnb, int vnd, const unsigned long *vd);

void div_on_help_unsigned(small_type &us,
                          int unb, int und, unsigned long *ud,
                          int vnb, int vnd, const unsigned long *vd);

extern
void mod_on_help_unsigned(small_type &us,
                          int unb, int und, unsigned long *ud,
                          int vnb, int vnd, const unsigned long *vd);

extern
void and_on_help(small_type us,
                 int unb, int und, unsigned long *ud,
                 small_type vs,
                 int vnb, int vnd, const unsigned long *vd);

extern
void or_on_help(small_type us,
                int unb, int und, unsigned long *ud,
                small_type vs,
                int vnb, int vnd, const unsigned long *vd);

extern
void xor_on_help(small_type us,
                 int unb, int und, unsigned long *ud,
                 small_type vs,
                 int vnb, int vnd, const unsigned long *vd);

}
# 78 "../../../src/systemc/datatypes/int/sc_signed.h" 2


namespace sc_dt
{


class sc_signed_bitref_r;
class sc_signed_bitref;
class sc_signed_subref_r;
class sc_signed_subref;
class sc_concatref;
class sc_signed;


class sc_bv_base;
class sc_lv_base;
class sc_int_base;
class sc_uint_base;
class sc_signed;
class sc_unsigned;
class sc_unsigned_subref_r;
class sc_fxval;
class sc_fxval_fast;
class sc_fxnum;
class sc_fxnum_fast;
# 111 "../../../src/systemc/datatypes/int/sc_signed.h"
class sc_signed_bitref_r : public sc_value_base
{
    friend class sc_signed;

protected:



    sc_signed_bitref_r( const sc_signed& obj_, int index_ )
 : m_obj_p( const_cast<sc_signed*>( &obj_ ) ), m_index( index_ )
 {}


public:



    virtual ~sc_signed_bitref_r()
 {}



    sc_signed_bitref_r( const sc_signed_bitref_r& a )
 : m_obj_p( a.m_obj_p ), m_index( a.m_index )
 {}




    sc_signed_bitref_r* clone() const
 { return new sc_signed_bitref_r( *this ); }




    int length() const
 { return 1; }




    operator bool () const;
    bool operator ! () const;
    bool operator ~ () const;




    bool value() const
 { return operator bool(); }

    bool to_bool() const
 { return operator bool(); }



    virtual int concat_length(bool* xz_present_p) const
        { if ( xz_present_p ) *xz_present_p = false; return 1; }
    virtual uint64 concat_get_uint64() const
 { return (uint64)operator bool(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const
 {
     int bit_mask = 1 << (low_i % 30);
     int word_i = low_i / 30;
     dst_p[word_i] &= ~bit_mask;
     return false;
        }
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const
 {
     int bit_mask = 1 << (low_i % 30);
     bool result;
     int word_i = low_i / 30;
     if ( operator bool() )
     {
  dst_p[word_i] |= bit_mask;
  result = true;
     }
     else
     {
  dst_p[word_i] &= ~bit_mask;
  result = false;
     }
     return result;
        }




    void print( ostream& os = cout ) const
 { os << to_bool(); }

protected:

    sc_signed* m_obj_p;
    int m_index;

private:


    sc_signed_bitref_r();
    sc_signed_bitref_r& operator = ( const sc_signed_bitref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_signed_bitref_r& );
# 227 "../../../src/systemc/datatypes/int/sc_signed.h"
class sc_signed_bitref
    : public sc_signed_bitref_r
{
    friend class sc_signed;




    sc_signed_bitref( sc_signed& obj_, int index_ )
 : sc_signed_bitref_r( obj_, index_ )
 {}

public:



    sc_signed_bitref( const sc_signed_bitref& a )
 : sc_signed_bitref_r( a )
 {}




    sc_signed_bitref* clone() const
 { return new sc_signed_bitref( *this ); }




    sc_signed_bitref& operator = ( const sc_signed_bitref_r& );
    sc_signed_bitref& operator = ( const sc_signed_bitref& );
    sc_signed_bitref& operator = ( bool );

    sc_signed_bitref& operator &= ( bool );
    sc_signed_bitref& operator |= ( bool );
    sc_signed_bitref& operator ^= ( bool );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    void scan( istream& is = cin );

private:


    sc_signed_bitref();
};



inline
istream&
operator >> ( istream&, sc_signed_bitref& );
# 295 "../../../src/systemc/datatypes/int/sc_signed.h"
class sc_signed_subref_r : public sc_value_base
{
    friend class sc_signed;
    friend class sc_signed_signal;

protected:



    sc_signed_subref_r( const sc_signed& obj_, int left_, int right_ )
 : m_obj_p( const_cast<sc_signed*>( &obj_ ) ),
   m_left( left_ ), m_right( right_ )
 {}
    sc_signed_subref_r()
 {}


public:



    virtual ~sc_signed_subref_r()
 {}



    sc_signed_subref_r( const sc_signed_subref_r& a )
 : m_obj_p( a.m_obj_p ), m_left( a.m_left ), m_right( a.m_right )
 {}




    sc_signed_subref_r* clone() const
 { return new sc_signed_subref_r( *this ); }




    int length() const
        { return ( m_left - m_right + 1 ); }




    operator sc_signed () const;




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;




    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    virtual int concat_length(bool* xz_present_p) const
        {
     if ( xz_present_p ) *xz_present_p = false;
     return m_left - m_right + 1;
        }
    virtual uint64 concat_get_uint64() const;
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;



    bool and_reduce() const;
    bool nand_reduce() const;
    bool or_reduce() const;
    bool nor_reduce() const;
    bool xor_reduce() const ;
    bool xnor_reduce() const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

protected:

    sc_signed* m_obj_p;
    int m_left;
    int m_right;

private:


    sc_signed_subref_r& operator = ( const sc_signed_subref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_signed_subref_r& );
# 411 "../../../src/systemc/datatypes/int/sc_signed.h"
class sc_signed_subref
    : public sc_signed_subref_r
{
    friend class sc_signed;




    sc_signed_subref( sc_signed& obj_, int left_, int right_ )
 : sc_signed_subref_r( obj_, left_, right_ )
 {}

public:



    sc_signed_subref( const sc_signed_subref& a )
 : sc_signed_subref_r( a )
 {}




    sc_signed_subref* clone() const
 { return new sc_signed_subref( *this ); }




    sc_signed_subref& operator = ( const sc_signed_subref_r& a );
    sc_signed_subref& operator = ( const sc_signed_subref& a );
    sc_signed_subref& operator = ( const sc_signed& a );

    sc_signed_subref& operator = ( const sc_concatref& a );

    sc_signed_subref& operator = ( const sc_unsigned_subref_r& a );
    sc_signed_subref& operator = ( const sc_unsigned& a );

    sc_signed_subref& operator = ( const char* a );
    sc_signed_subref& operator = ( unsigned long a );
    sc_signed_subref& operator = ( long a );

    sc_signed_subref& operator = ( unsigned int a )
 { return operator = ( (unsigned long) a ); }

    sc_signed_subref& operator = ( int a )
 { return operator = ( (long) a ); }

    sc_signed_subref& operator = ( uint64 a );
    sc_signed_subref& operator = ( int64 a );
    sc_signed_subref& operator = ( double a );
    sc_signed_subref& operator = ( const sc_int_base& a );
    sc_signed_subref& operator = ( const sc_uint_base& a );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    void scan( istream& is = cin );

private:


    sc_signed_subref();
};



inline
istream&
operator >> ( istream&, sc_signed_subref& );
# 495 "../../../src/systemc/datatypes/int/sc_signed.h"
class sc_signed : public sc_value_base
{
 friend class sc_concatref;
    friend class sc_signed_bitref_r;
    friend class sc_signed_bitref;
    friend class sc_signed_subref_r;
    friend class sc_signed_subref;
    friend class sc_unsigned;
    friend class sc_unsigned_subref;


  typedef bool elemtype;

public:



    explicit sc_signed( int nb = sc_length_param().len() );
    sc_signed( const sc_signed& v );
    sc_signed( const sc_unsigned& v );




    sc_signed& operator = (const sc_signed& v);
    sc_signed& operator = (const sc_signed_subref_r& a );

    sc_signed& operator = ( const sc_concatref& a );

    sc_signed& operator = (const sc_unsigned& v);
    sc_signed& operator = (const sc_unsigned_subref_r& a );

    sc_signed& operator = (const char* v);
    sc_signed& operator = (int64 v);
    sc_signed& operator = (uint64 v);
    sc_signed& operator = (long v);
    sc_signed& operator = (unsigned long v);

    sc_signed& operator = (int v)
 { return operator=((long) v); }

    sc_signed& operator = (unsigned int v)
 { return operator=((unsigned long) v); }

    sc_signed& operator = (double v);
    sc_signed& operator = (const sc_int_base& v);
    sc_signed& operator = (const sc_uint_base& v);

    sc_signed& operator = ( const sc_bv_base& );
    sc_signed& operator = ( const sc_lv_base& );


    sc_signed& operator = ( const sc_fxval& );
    sc_signed& operator = ( const sc_fxval_fast& );
    sc_signed& operator = ( const sc_fxnum& );
    sc_signed& operator = ( const sc_fxnum_fast& );





    virtual ~sc_signed()
 {

     delete [] digit;

 }



    unsigned long* get_raw() const
 { return digit; }
    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return nbits; }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const;
    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    sc_signed& operator ++ ();
    const sc_signed operator ++ (int);


    sc_signed& operator -- ();
    const sc_signed operator -- (int);




    sc_signed_bitref operator [] ( int i )
 { return sc_signed_bitref( *this, i ); }

    sc_signed_bitref_r operator [] ( int i ) const
 { return sc_signed_bitref_r( *this, i ); }

    sc_signed_bitref bit( int i )
 { return sc_signed_bitref( *this, i ); }

    sc_signed_bitref_r bit( int i ) const
 { return sc_signed_bitref_r( *this, i ); }
# 612 "../../../src/systemc/datatypes/int/sc_signed.h"
    sc_signed_subref range( int i, int j )
 { return sc_signed_subref( *this, i, j ); }

    sc_signed_subref_r range( int i, int j ) const
 { return sc_signed_subref_r( *this, i, j ); }

    sc_signed_subref operator () ( int i, int j )
 { return sc_signed_subref( *this, i, j ); }

    sc_signed_subref_r operator () ( int i, int j ) const
 { return sc_signed_subref_r( *this, i, j ); }




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;
# 645 "../../../src/systemc/datatypes/int/sc_signed.h"
    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

    void scan( istream& is = cin );

    void dump( ostream& os = cout ) const;



  int length() const { return nbits; }
  bool iszero() const;
  bool sign() const;



    bool and_reduce() const;

    bool nand_reduce() const
        { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
        { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
        { return ( ! xor_reduce() ); }


  bool test(int i) const;
  void set(int i);
  void clear(int i);
  void set(int i, bool v)
    { if (v) set(i); else clear(i); }
  void invert(int i)
    { if (test(i)) clear(i); else set(i); }


  void reverse();


  void get_packed_rep(unsigned long *buf) const;
  void set_packed_rep(unsigned long *buf);
# 730 "../../../src/systemc/datatypes/int/sc_signed.h"
  friend sc_signed operator + (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator + (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator + (const sc_unsigned& u, int64 v);
  friend sc_signed operator + (const sc_unsigned& u, long v);
  friend sc_signed operator + (const sc_unsigned& u, int v)
    { return operator+(u, (long) v); }

  friend sc_signed operator + (int64 u, const sc_unsigned& v);
  friend sc_signed operator + (long u, const sc_unsigned& v);
  friend sc_signed operator + (int u, const sc_unsigned& v)
    { return operator+((long) u, v); }

  friend sc_signed operator + (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator + (const sc_signed& u, int64 v);
  friend sc_signed operator + (const sc_signed& u, uint64 v);
  friend sc_signed operator + (const sc_signed& u, long v);
  friend sc_signed operator + (const sc_signed& u, unsigned long v);
  friend sc_signed operator + (const sc_signed& u, int v)
    { return operator+(u, (long) v); }
  friend sc_signed operator + (const sc_signed& u, unsigned int v)
    { return operator+(u, (unsigned long) v); }

  friend sc_signed operator + (int64 u, const sc_signed& v);
  friend sc_signed operator + (uint64 u, const sc_signed& v);
  friend sc_signed operator + (long u, const sc_signed& v);
  friend sc_signed operator + (unsigned long u, const sc_signed& v);
  friend sc_signed operator + (int u, const sc_signed& v)
    { return operator+((long) u, v); }
  friend sc_signed operator + (unsigned int u, const sc_signed& v)
    { return operator+((unsigned long) u, v); }

  sc_signed& operator += (const sc_signed& v);
  sc_signed& operator += (const sc_unsigned& v);
  sc_signed& operator += (int64 v);
  sc_signed& operator += (uint64 v);
  sc_signed& operator += (long v);
  sc_signed& operator += (unsigned long v);
  sc_signed& operator += (int v)
    { return operator+=((long) v); }
  sc_signed& operator += (unsigned int v)
    { return operator+=((unsigned long) v); }

  friend sc_signed operator + (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator + (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator + (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator + (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator + (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator + (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator += (const sc_int_base& v);
  sc_signed& operator += (const sc_uint_base& v);



  friend sc_signed operator - (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator - (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator - (const sc_unsigned& u, int64 v);
  friend sc_signed operator - (const sc_unsigned& u, uint64 v);
  friend sc_signed operator - (const sc_unsigned& u, long v);
  friend sc_signed operator - (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator - (const sc_unsigned& u, int v)
    { return operator-(u, (long) v); }
  friend sc_signed operator - (const sc_unsigned& u, unsigned int v)
    { return operator-(u, (unsigned long) v); }

  friend sc_signed operator - (int64 u, const sc_unsigned& v);
  friend sc_signed operator - (uint64 u, const sc_unsigned& v);
  friend sc_signed operator - (long u, const sc_unsigned& v);
  friend sc_signed operator - (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator - (int u, const sc_unsigned& v)
    { return operator-((long) u, v); }
  friend sc_signed operator - (unsigned int u, const sc_unsigned& v)
    { return operator-((unsigned long) u, v); }

  friend sc_signed operator - (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator - (const sc_signed& u, int64 v);
  friend sc_signed operator - (const sc_signed& u, uint64 v);
  friend sc_signed operator - (const sc_signed& u, long v);
  friend sc_signed operator - (const sc_signed& u, unsigned long v);
  friend sc_signed operator - (const sc_signed& u, int v)
    { return operator-(u, (long) v); }
  friend sc_signed operator - (const sc_signed& u, unsigned int v)
    { return operator-(u, (unsigned long) v); }

  friend sc_signed operator - (int64 u, const sc_signed& v);
  friend sc_signed operator - (uint64 u, const sc_signed& v);
  friend sc_signed operator - (long u, const sc_signed& v);
  friend sc_signed operator - (unsigned long u, const sc_signed& v);
  friend sc_signed operator - (int u, const sc_signed& v)
    { return operator-((long) u, v); }
  friend sc_signed operator - (unsigned int u, const sc_signed& v)
    { return operator-((unsigned long) u, v); }

  sc_signed& operator -= (const sc_signed& v);
  sc_signed& operator -= (const sc_unsigned& v);
  sc_signed& operator -= (int64 v);
  sc_signed& operator -= (uint64 v);
  sc_signed& operator -= (long v);
  sc_signed& operator -= (unsigned long v);
  sc_signed& operator -= (int v)
    { return operator -= ((long) v); }
  sc_signed& operator -= (unsigned int v)
    { return operator -= ((unsigned long) v); }

  friend sc_signed operator - (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator - (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator - (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator - (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator - (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator - (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator -= (const sc_int_base& v);
  sc_signed& operator -= (const sc_uint_base& v);



  friend sc_signed operator * (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator * (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator * (const sc_unsigned& u, int64 v);
  friend sc_signed operator * (const sc_unsigned& u, long v);
  friend sc_signed operator * (const sc_unsigned& u, int v)
    { return operator*(u, (long) v); }

  friend sc_signed operator * (int64 u, const sc_unsigned& v);
  friend sc_signed operator * (long u, const sc_unsigned& v);
  friend sc_signed operator * (int u, const sc_unsigned& v)
    { return operator*((long) u, v); }

  friend sc_signed operator * (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator * (const sc_signed& u, int64 v);
  friend sc_signed operator * (const sc_signed& u, uint64 v);
  friend sc_signed operator * (const sc_signed& u, long v);
  friend sc_signed operator * (const sc_signed& u, unsigned long v);
  friend sc_signed operator * (const sc_signed& u, int v)
    { return operator*(u, (long) v); }
  friend sc_signed operator * (const sc_signed& u, unsigned int v)
    { return operator*(u, (unsigned long) v); }

  friend sc_signed operator * (int64 u, const sc_signed& v);
  friend sc_signed operator * (uint64 u, const sc_signed& v);
  friend sc_signed operator * (long u, const sc_signed& v);
  friend sc_signed operator * (unsigned long u, const sc_signed& v);
  friend sc_signed operator * (int u, const sc_signed& v)
    { return operator*((long) u, v); }
  friend sc_signed operator * (unsigned int u, const sc_signed& v)
    { return operator*((unsigned long) u, v); }

  sc_signed& operator *= (const sc_signed& v);
  sc_signed& operator *= (const sc_unsigned& v);
  sc_signed& operator *= (int64 v);
  sc_signed& operator *= (uint64 v);
  sc_signed& operator *= (long v);
  sc_signed& operator *= (unsigned long v);
  sc_signed& operator *= (int v)
    { return operator*=((long) v); }
  sc_signed& operator *= (unsigned int v)
    { return operator*=((unsigned long) v); }

  friend sc_signed operator * (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator * (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator * (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator * (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator * (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator * (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator *= (const sc_int_base& v);
  sc_signed& operator *= (const sc_uint_base& v);



  friend sc_signed operator / (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator / (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator / (const sc_unsigned& u, int64 v);
  friend sc_signed operator / (const sc_unsigned& u, long v);
  friend sc_signed operator / (const sc_unsigned& u, int v)
    { return operator/(u, (long) v); }

  friend sc_signed operator / (int64 u, const sc_unsigned& v);
  friend sc_signed operator / (long u, const sc_unsigned& v);
  friend sc_signed operator / (int u, const sc_unsigned& v)
    { return operator/((long) u, v); }

  friend sc_signed operator / (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator / (const sc_signed& u, int64 v);
  friend sc_signed operator / (const sc_signed& u, uint64 v);
  friend sc_signed operator / (const sc_signed& u, long v);
  friend sc_signed operator / (const sc_signed& u, unsigned long v);
  friend sc_signed operator / (const sc_signed& u, int v)
    { return operator/(u, (long) v); }
  friend sc_signed operator / (const sc_signed& u, unsigned int v)
    { return operator/(u, (unsigned long) v); }

  friend sc_signed operator / (int64 u, const sc_signed& v);
  friend sc_signed operator / (uint64 u, const sc_signed& v);
  friend sc_signed operator / (long u, const sc_signed& v);
  friend sc_signed operator / (unsigned long u, const sc_signed& v);
  friend sc_signed operator / (int u, const sc_signed& v)
    { return operator/((long) u, v); }
  friend sc_signed operator / (unsigned int u, const sc_signed& v)
    { return operator/((unsigned long) u, v); }

  sc_signed& operator /= (const sc_signed& v);
  sc_signed& operator /= (const sc_unsigned& v);
  sc_signed& operator /= (int64 v);
  sc_signed& operator /= (uint64 v);
  sc_signed& operator /= (long v);
  sc_signed& operator /= (unsigned long v);
  sc_signed& operator /= (int v)
    { return operator/=((long) v); }
  sc_signed& operator /= (unsigned int v)
    { return operator/=((unsigned long) v); }

  friend sc_signed operator / (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator / (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator / (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator / (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator / (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator / (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator /= (const sc_int_base& v);
  sc_signed& operator /= (const sc_uint_base& v);



  friend sc_signed operator % (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator % (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator % (const sc_unsigned& u, int64 v);
  friend sc_signed operator % (const sc_unsigned& u, long v);
  friend sc_signed operator % (const sc_unsigned& u, int v)
    { return operator%(u, (long) v); }

  friend sc_signed operator % (int64 u, const sc_unsigned& v);
  friend sc_signed operator % (long u, const sc_unsigned& v);
  friend sc_signed operator % (int u, const sc_unsigned& v)
    { return operator%((long) u, v); }

  friend sc_signed operator % (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator % (const sc_signed& u, int64 v);
  friend sc_signed operator % (const sc_signed& u, uint64 v);
  friend sc_signed operator % (const sc_signed& u, long v);
  friend sc_signed operator % (const sc_signed& u, unsigned long v);
  friend sc_signed operator % (const sc_signed& u, int v)
    { return operator%(u, (long) v); }
  friend sc_signed operator % (const sc_signed& u, unsigned int v)
    { return operator%(u, (unsigned long) v); }

  friend sc_signed operator % (int64 u, const sc_signed& v);
  friend sc_signed operator % (uint64 u, const sc_signed& v);
  friend sc_signed operator % (long u, const sc_signed& v);
  friend sc_signed operator % (unsigned long u, const sc_signed& v);
  friend sc_signed operator % (int u, const sc_signed& v)
    { return operator%((long) u, v); }
  friend sc_signed operator % (unsigned int u, const sc_signed& v)
    { return operator%((unsigned long) u, v); }

  sc_signed& operator %= (const sc_signed& v);
  sc_signed& operator %= (const sc_unsigned& v);
  sc_signed& operator %= (int64 v);
  sc_signed& operator %= (uint64 v);
  sc_signed& operator %= (long v);
  sc_signed& operator %= (unsigned long v);
  sc_signed& operator %= (int v)
    { return operator%=((long) v); }
  sc_signed& operator %= (unsigned int v)
    { return operator%=((unsigned long) v); }

  friend sc_signed operator % (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator % (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator % (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator % (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator % (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator % (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator %= (const sc_int_base& v);
  sc_signed& operator %= (const sc_uint_base& v);





  friend sc_signed operator & (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator & (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator & (const sc_unsigned& u, int64 v);
  friend sc_signed operator & (const sc_unsigned& u, long v);
  friend sc_signed operator & (const sc_unsigned& u, int v)
    { return operator&(u, (long) v); }

  friend sc_signed operator & (int64 u, const sc_unsigned& v);
  friend sc_signed operator & (long u, const sc_unsigned& v);
  friend sc_signed operator & (int u, const sc_unsigned& v)
    { return operator&((long) u, v); }

  friend sc_signed operator & (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator & (const sc_signed& u, int64 v);
  friend sc_signed operator & (const sc_signed& u, uint64 v);
  friend sc_signed operator & (const sc_signed& u, long v);
  friend sc_signed operator & (const sc_signed& u, unsigned long v);
  friend sc_signed operator & (const sc_signed& u, int v)
    { return operator&(u, (long) v); }
  friend sc_signed operator & (const sc_signed& u, unsigned int v)
    { return operator&(u, (unsigned long) v); }

  friend sc_signed operator & (int64 u, const sc_signed& v);
  friend sc_signed operator & (uint64 u, const sc_signed& v);
  friend sc_signed operator & (long u, const sc_signed& v);
  friend sc_signed operator & (unsigned long u, const sc_signed& v);
  friend sc_signed operator & (int u, const sc_signed& v)
    { return operator&((long) u, v); }
  friend sc_signed operator & (unsigned int u, const sc_signed& v)
    { return operator&((unsigned long) u, v); }

  sc_signed& operator &= (const sc_signed& v);
  sc_signed& operator &= (const sc_unsigned& v);
  sc_signed& operator &= (int64 v);
  sc_signed& operator &= (uint64 v);
  sc_signed& operator &= (long v);
  sc_signed& operator &= (unsigned long v);
  sc_signed& operator &= (int v)
    { return operator&=((long) v); }
  sc_signed& operator &= (unsigned int v)
    { return operator&=((unsigned long) v); }

  friend sc_signed operator & (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator & (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator & (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator & (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator & (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator & (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator &= (const sc_int_base& v);
  sc_signed& operator &= (const sc_uint_base& v);



  friend sc_signed operator | (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator | (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator | (const sc_unsigned& u, int64 v);
  friend sc_signed operator | (const sc_unsigned& u, long v);
  friend sc_signed operator | (const sc_unsigned& u, int v)
    { return operator|(u, (long) v); }

  friend sc_signed operator | (int64 u, const sc_unsigned& v);
  friend sc_signed operator | (long u, const sc_unsigned& v);
  friend sc_signed operator | (int u, const sc_unsigned& v)
    { return operator|((long) u, v); }

  friend sc_signed operator | (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator | (const sc_signed& u, int64 v);
  friend sc_signed operator | (const sc_signed& u, uint64 v);
  friend sc_signed operator | (const sc_signed& u, long v);
  friend sc_signed operator | (const sc_signed& u, unsigned long v);
  friend sc_signed operator | (const sc_signed& u, int v)
    { return operator|(u, (long) v); }
  friend sc_signed operator | (const sc_signed& u, unsigned int v)
    { return operator|(u, (unsigned long) v); }

  friend sc_signed operator | (int64 u, const sc_signed& v);
  friend sc_signed operator | (uint64 u, const sc_signed& v);
  friend sc_signed operator | (long u, const sc_signed& v);
  friend sc_signed operator | (unsigned long u, const sc_signed& v);
  friend sc_signed operator | (int u, const sc_signed& v)
    { return operator|((long) u, v); }
  friend sc_signed operator | (unsigned int u, const sc_signed& v)
    { return operator|((unsigned long) u, v); }

  sc_signed& operator |= (const sc_signed& v);
  sc_signed& operator |= (const sc_unsigned& v);
  sc_signed& operator |= (int64 v);
  sc_signed& operator |= (uint64 v);
  sc_signed& operator |= (long v);
  sc_signed& operator |= (unsigned long v);
  sc_signed& operator |= (int v)
    { return operator|=((long) v); }
  sc_signed& operator |= (unsigned int v)
    { return operator|=((unsigned long) v); }

  friend sc_signed operator | (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator | (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator | (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator | (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator | (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator | (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator |= (const sc_int_base& v);
  sc_signed& operator |= (const sc_uint_base& v);



  friend sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator ^ (const sc_unsigned& u, int64 v);
  friend sc_signed operator ^ (const sc_unsigned& u, long v);
  friend sc_signed operator ^ (const sc_unsigned& u, int v)
    { return operator^(u, (long) v); }

  friend sc_signed operator ^ (int64 u, const sc_unsigned& v);
  friend sc_signed operator ^ (long u, const sc_unsigned& v);
  friend sc_signed operator ^ (int u, const sc_unsigned& v)
    { return operator^((long) u, v); }

  friend sc_signed operator ^ (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator ^ (const sc_signed& u, int64 v);
  friend sc_signed operator ^ (const sc_signed& u, uint64 v);
  friend sc_signed operator ^ (const sc_signed& u, long v);
  friend sc_signed operator ^ (const sc_signed& u, unsigned long v);
  friend sc_signed operator ^ (const sc_signed& u, int v)
    { return operator^(u, (long) v); }
  friend sc_signed operator ^ (const sc_signed& u, unsigned int v)
    { return operator^(u, (unsigned long) v); }

  friend sc_signed operator ^ (int64 u, const sc_signed& v);
  friend sc_signed operator ^ (uint64 u, const sc_signed& v);
  friend sc_signed operator ^ (long u, const sc_signed& v);
  friend sc_signed operator ^ (unsigned long u, const sc_signed& v);
  friend sc_signed operator ^ (int u, const sc_signed& v)
    { return operator^((long) u, v); }
  friend sc_signed operator ^ (unsigned int u, const sc_signed& v)
    { return operator^((unsigned long) u, v); }

  sc_signed& operator ^= (const sc_signed& v);
  sc_signed& operator ^= (const sc_unsigned& v);
  sc_signed& operator ^= (int64 v);
  sc_signed& operator ^= (uint64 v);
  sc_signed& operator ^= (long v);
  sc_signed& operator ^= (unsigned long v);
  sc_signed& operator ^= (int v)
    { return operator^=((long) v); }
  sc_signed& operator ^= (unsigned int v)
    { return operator^=((unsigned long) v); }

  friend sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v);
  friend sc_signed operator ^ (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator ^ (const sc_signed& u, const sc_uint_base& v);
  friend sc_signed operator ^ (const sc_int_base& u, const sc_signed& v);
  friend sc_signed operator ^ (const sc_uint_base& u, const sc_signed& v);
  sc_signed& operator ^= (const sc_int_base& v);
  sc_signed& operator ^= (const sc_uint_base& v);





  friend sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator << (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator << (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator << (const sc_signed& u, int64 v);
  friend sc_signed operator << (const sc_signed& u, uint64 v);
  friend sc_signed operator << (const sc_signed& u, long v);
  friend sc_signed operator << (const sc_signed& u, unsigned long v);
  friend sc_signed operator << (const sc_signed& u, int v)
    { return operator<<(u, (long) v); }
  friend sc_signed operator << (const sc_signed& u, unsigned int v)
    { return operator<<(u, (unsigned long) v); }

  sc_signed& operator <<= (const sc_signed& v);
  sc_signed& operator <<= (const sc_unsigned& v);
  sc_signed& operator <<= (int64 v);
  sc_signed& operator <<= (uint64 v);
  sc_signed& operator <<= (long v);
  sc_signed& operator <<= (unsigned long v);
  sc_signed& operator <<= (int v)
    { return operator<<=((long) v); }
  sc_signed& operator <<= (unsigned int v)
    { return operator<<=((unsigned long) v); }

  friend sc_signed operator << (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator << (const sc_signed& u, const sc_uint_base& v);
  sc_signed& operator <<= (const sc_int_base& v);
  sc_signed& operator <<= (const sc_uint_base& v);



  friend sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator >> (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator >> (const sc_signed& u, const sc_signed& v);
  friend sc_signed operator >> (const sc_signed& u, int64 v);
  friend sc_signed operator >> (const sc_signed& u, uint64 v);
  friend sc_signed operator >> (const sc_signed& u, long v);
  friend sc_signed operator >> (const sc_signed& u, unsigned long v);
  friend sc_signed operator >> (const sc_signed& u, int v)
    { return operator>>(u, (long) v); }
  friend sc_signed operator >> (const sc_signed& u, unsigned int v)
    { return operator>>(u, (unsigned long) v); }

  sc_signed& operator >>= (const sc_signed& v);
  sc_signed& operator >>= (const sc_unsigned& v);
  sc_signed& operator >>= (int64 v);
  sc_signed& operator >>= (uint64 v);
  sc_signed& operator >>= (long v);
  sc_signed& operator >>= (unsigned long v);
  sc_signed& operator >>= (int v)
    { return operator>>=((long) v); }
  sc_signed& operator >>= (unsigned int v)
    { return operator>>=((unsigned long) v); }

  friend sc_signed operator >> (const sc_signed& u, const sc_int_base& v);
  friend sc_signed operator >> (const sc_signed& u, const sc_uint_base& v);
  sc_signed& operator >>= (const sc_int_base& v);
  sc_signed& operator >>= (const sc_uint_base& v);


  friend sc_signed operator + (const sc_signed& u);
  friend sc_signed operator - (const sc_signed& u);
  friend sc_signed operator - (const sc_unsigned& u);





  friend bool operator == (const sc_unsigned& u, const sc_signed& v);
  friend bool operator == (const sc_signed& u, const sc_unsigned& v);

  friend bool operator == (const sc_signed& u, const sc_signed& v);
  friend bool operator == (const sc_signed& u, int64 v);
  friend bool operator == (const sc_signed& u, uint64 v);
  friend bool operator == (const sc_signed& u, long v);
  friend bool operator == (const sc_signed& u, unsigned long v);
  friend bool operator == (const sc_signed& u, int v)
    { return operator==(u, (long) v); }
  friend bool operator == (const sc_signed& u, unsigned int v)
    { return operator==(u, (unsigned long) v); }

  friend bool operator == (int64 u, const sc_signed& v);
  friend bool operator == (uint64 u, const sc_signed& v);
  friend bool operator == (long u, const sc_signed& v);
  friend bool operator == (unsigned long u, const sc_signed& v);
  friend bool operator == (int u, const sc_signed& v)
    { return operator==((long) u, v); }
  friend bool operator == (unsigned int u, const sc_signed& v)
    { return operator==((unsigned long) u, v); }

  friend bool operator == (const sc_signed& u, const sc_int_base& v);
  friend bool operator == (const sc_signed& u, const sc_uint_base& v);
  friend bool operator == (const sc_int_base& u, const sc_signed& v);
  friend bool operator == (const sc_uint_base& u, const sc_signed& v);



  friend bool operator != (const sc_unsigned& u, const sc_signed& v);
  friend bool operator != (const sc_signed& u, const sc_unsigned& v);

  friend bool operator != (const sc_signed& u, const sc_signed& v);
  friend bool operator != (const sc_signed& u, int64 v);
  friend bool operator != (const sc_signed& u, uint64 v);
  friend bool operator != (const sc_signed& u, long v);
  friend bool operator != (const sc_signed& u, unsigned long v);
  friend bool operator != (const sc_signed& u, int v)
    { return operator!=(u, (long) v); }
  friend bool operator != (const sc_signed& u, unsigned int v)
    { return operator!=(u, (unsigned long) v); }

  friend bool operator != (int64 u, const sc_signed& v);
  friend bool operator != (uint64 u, const sc_signed& v);
  friend bool operator != (long u, const sc_signed& v);
  friend bool operator != (unsigned long u, const sc_signed& v);
  friend bool operator != (int u, const sc_signed& v)
    { return operator!=((long) u, v); }
  friend bool operator != (unsigned int u, const sc_signed& v)
    { return operator!=((unsigned long) u, v); }

  friend bool operator != (const sc_signed& u, const sc_int_base& v);
  friend bool operator != (const sc_signed& u, const sc_uint_base& v);
  friend bool operator != (const sc_int_base& u, const sc_signed& v);
  friend bool operator != (const sc_uint_base& u, const sc_signed& v);



  friend bool operator < (const sc_unsigned& u, const sc_signed& v);
  friend bool operator < (const sc_signed& u, const sc_unsigned& v);

  friend bool operator < (const sc_signed& u, const sc_signed& v);
  friend bool operator < (const sc_signed& u, int64 v);
  friend bool operator < (const sc_signed& u, uint64 v);
  friend bool operator < (const sc_signed& u, long v);
  friend bool operator < (const sc_signed& u, unsigned long v);
  friend bool operator < (const sc_signed& u, int v)
    { return operator<(u, (long) v); }
  friend bool operator < (const sc_signed& u, unsigned int v)
    { return operator<(u, (unsigned long) v); }

  friend bool operator < (int64 u, const sc_signed& v);
  friend bool operator < (uint64 u, const sc_signed& v);
  friend bool operator < (long u, const sc_signed& v);
  friend bool operator < (unsigned long u, const sc_signed& v);
  friend bool operator < (int u, const sc_signed& v)
    { return operator<((long) u, v); }
  friend bool operator < (unsigned int u, const sc_signed& v)
    { return operator<((unsigned long) u, v); }

  friend bool operator < (const sc_signed& u, const sc_int_base& v);
  friend bool operator < (const sc_signed& u, const sc_uint_base& v);
  friend bool operator < (const sc_int_base& u, const sc_signed& v);
  friend bool operator < (const sc_uint_base& u, const sc_signed& v);



  friend bool operator <= (const sc_unsigned& u, const sc_signed& v);
  friend bool operator <= (const sc_signed& u, const sc_unsigned& v);

  friend bool operator <= (const sc_signed& u, const sc_signed& v);
  friend bool operator <= (const sc_signed& u, int64 v);
  friend bool operator <= (const sc_signed& u, uint64 v);
  friend bool operator <= (const sc_signed& u, long v);
  friend bool operator <= (const sc_signed& u, unsigned long v);
  friend bool operator <= (const sc_signed& u, int v)
    { return operator<=(u, (long) v); }
  friend bool operator <= (const sc_signed& u, unsigned int v)
    { return operator<=(u, (unsigned long) v); }

  friend bool operator <= (int64 u, const sc_signed& v);
  friend bool operator <= (uint64 u, const sc_signed& v);
  friend bool operator <= (long u, const sc_signed& v);
  friend bool operator <= (unsigned long u, const sc_signed& v);
  friend bool operator <= (int u, const sc_signed& v)
    { return operator<=((long) u, v); }
  friend bool operator <= (unsigned int u, const sc_signed& v)
    { return operator<=((unsigned long) u, v); }

  friend bool operator <= (const sc_signed& u, const sc_int_base& v);
  friend bool operator <= (const sc_signed& u, const sc_uint_base& v);
  friend bool operator <= (const sc_int_base& u, const sc_signed& v);
  friend bool operator <= (const sc_uint_base& u, const sc_signed& v);



  friend bool operator > (const sc_unsigned& u, const sc_signed& v);
  friend bool operator > (const sc_signed& u, const sc_unsigned& v);

  friend bool operator > (const sc_signed& u, const sc_signed& v);
  friend bool operator > (const sc_signed& u, int64 v);
  friend bool operator > (const sc_signed& u, uint64 v);
  friend bool operator > (const sc_signed& u, long v);
  friend bool operator > (const sc_signed& u, unsigned long v);
  friend bool operator > (const sc_signed& u, int v)
    { return operator>(u, (long) v); }
  friend bool operator > (const sc_signed& u, unsigned int v)
    { return operator>(u, (unsigned long) v); }

  friend bool operator > (int64 u, const sc_signed& v);
  friend bool operator > (uint64 u, const sc_signed& v);
  friend bool operator > (long u, const sc_signed& v);
  friend bool operator > (unsigned long u, const sc_signed& v);
  friend bool operator > (int u, const sc_signed& v)
    { return operator>((long) u, v); }
  friend bool operator > (unsigned int u, const sc_signed& v)
    { return operator>((unsigned long) u, v); }

  friend bool operator > (const sc_signed& u, const sc_int_base& v);
  friend bool operator > (const sc_signed& u, const sc_uint_base& v);
  friend bool operator > (const sc_int_base& u, const sc_signed& v);
  friend bool operator > (const sc_uint_base& u, const sc_signed& v);



  friend bool operator >= (const sc_unsigned& u, const sc_signed& v);
  friend bool operator >= (const sc_signed& u, const sc_unsigned& v);

  friend bool operator >= (const sc_signed& u, const sc_signed& v);
  friend bool operator >= (const sc_signed& u, int64 v);
  friend bool operator >= (const sc_signed& u, uint64 v);
  friend bool operator >= (const sc_signed& u, long v);
  friend bool operator >= (const sc_signed& u, unsigned long v);
  friend bool operator >= (const sc_signed& u, int v)
    { return operator>=(u, (long) v); }
  friend bool operator >= (const sc_signed& u, unsigned int v)
    { return operator>=(u, (unsigned long) v); }

  friend bool operator >= (int64 u, const sc_signed& v);
  friend bool operator >= (uint64 u, const sc_signed& v);
  friend bool operator >= (long u, const sc_signed& v);
  friend bool operator >= (unsigned long u, const sc_signed& v);
  friend bool operator >= (int u, const sc_signed& v)
    { return operator>=((long) u, v); }
  friend bool operator >= (unsigned int u, const sc_signed& v)
    { return operator>=((unsigned long) u, v); }

  friend bool operator >= (const sc_signed& u, const sc_int_base& v);
  friend bool operator >= (const sc_signed& u, const sc_uint_base& v);
  friend bool operator >= (const sc_int_base& u, const sc_signed& v);
  friend bool operator >= (const sc_uint_base& u, const sc_signed& v);


  friend sc_signed operator ~ (const sc_signed& u);


  friend sc_signed add_signed_friend(small_type us,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     small_type vs,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed sub_signed_friend(small_type us,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     small_type vs,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed mul_signed_friend(small_type s,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed div_signed_friend(small_type s,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed mod_signed_friend(small_type us,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed and_signed_friend(small_type us,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     small_type vs,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

  friend sc_signed or_signed_friend(small_type us,
                                    int unb,
                                    int und,
                                    const unsigned long *ud,
                                    small_type vs,
                                    int vnb,
                                    int vnd,
                                    const unsigned long *vd);

  friend sc_signed xor_signed_friend(small_type us,
                                     int unb,
                                     int und,
                                     const unsigned long *ud,
                                     small_type vs,
                                     int vnb,
                                     int vnd,
                                     const unsigned long *vd);

private:

  small_type sgn;
  int nbits;
  int ndigits;




  unsigned long *digit;





  sc_signed(const sc_signed& v, small_type s);
  sc_signed(const sc_unsigned& v, small_type s);


  sc_signed(small_type s, int nb, int nd,
            unsigned long *d, bool alloc = true);


  sc_signed(const sc_signed* u, int l, int r);



  small_type default_sign() const
    { return 2; }

  int num_bits(int nb) const { return nb; }

  bool check_if_outside(int bit_num) const;

  void copy_digits(int nb, int nd, const unsigned long *d)
    { copy_digits_signed(sgn, nbits, ndigits, digit, nb, nd, d); }

  void makezero()
    { sgn = make_zero(ndigits, digit); }



  void convert_2C_to_SM()
    { sgn = convert_signed_2C_to_SM(nbits, ndigits, digit); }

  void convert_SM_to_2C_to_SM()
    { sgn = convert_signed_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }

  void convert_SM_to_2C()
    { convert_signed_SM_to_2C(sgn, ndigits, digit); }

};



inline
ostream&
operator << ( ostream&, const sc_signed& );

inline
istream&
operator >> ( istream&, sc_signed& );



inline
ostream&
operator << ( ostream& os, const sc_signed_bitref_r& a )
{
    a.print( os );
    return os;
}


inline
istream&
operator >> ( istream& is, sc_signed_bitref& a )
{
    a.scan( is );
    return is;
}
# 1583 "../../../src/systemc/datatypes/int/sc_signed.h"
inline bool sc_signed_subref_r::and_reduce() const
{
   const sc_signed* target_p = m_obj_p;
   for ( int i = m_right; i <= m_left; i++ )
 if ( !target_p->test(i) ) return false;
   return true;
}

inline bool sc_signed_subref_r::nand_reduce() const
{
    return !and_reduce();
}

inline bool sc_signed_subref_r::or_reduce() const
{
   const sc_signed* target_p = m_obj_p;
   for ( int i = m_right; i <= m_left; i++ )
 if ( target_p->test(i) ) return true;
   return false;
}

inline bool sc_signed_subref_r::nor_reduce() const
{
    return !or_reduce();
}

inline bool sc_signed_subref_r::xor_reduce() const
{
   int odd;
   const sc_signed* target_p = m_obj_p;
   odd = 0;
   for ( int i = m_right; i <= m_left; i++ )
 if ( target_p->test(i) ) odd = ~odd;
   return odd ? true : false;
}

inline bool sc_signed_subref_r::xnor_reduce() const
{
    return !xor_reduce();
}

inline
ostream&
operator << ( ostream& os, const sc_signed_subref_r& a )
{
    a.print( os );
    return os;
}
# 1641 "../../../src/systemc/datatypes/int/sc_signed.h"
inline
sc_signed_subref&
sc_signed_subref::operator = ( const char* a )
{
    sc_signed aa( length() );
    return ( *this = aa = a );
}




inline
istream&
operator >> ( istream& is, sc_signed_subref& a )
{
    a.scan( is );
    return is;
}
# 1669 "../../../src/systemc/datatypes/int/sc_signed.h"
inline
ostream&
operator << ( ostream& os, const sc_signed& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_signed& a )
{
    a.scan( is );
    return is;
}


}
# 51 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_unsigned.h" 1
# 82 "../../../src/systemc/datatypes/int/sc_unsigned.h"
# 1 "../../../src/systemc/utils/sc_temporary.h" 1
# 76 "../../../src/systemc/utils/sc_temporary.h"
class sc_byte_heap {
  public:
    char* m_bgn_p;
    char* m_end_p;
    char* m_next_p;

    inline char* allocate( int bytes_n )
    {
        char* result_p;
        bytes_n = (bytes_n + 7) & 0xfffffff8;
        result_p = m_next_p;
        m_next_p += bytes_n;
        if ( m_next_p >= m_end_p )
        {
            result_p = m_bgn_p;
            m_next_p = m_bgn_p + bytes_n;
        }
        return result_p;
    }

    inline void initialize( int heap_size=0x100000 )
    {
  if ( m_bgn_p ) delete [] m_bgn_p;
        m_bgn_p = new char[heap_size];
        m_end_p = &m_bgn_p[heap_size];
        m_next_p = m_bgn_p;
    }

 inline unsigned int length()
 {
  return (unsigned int)(m_end_p - m_bgn_p);
 }

 inline sc_byte_heap()
 {
  m_bgn_p = 0;
 }

 inline sc_byte_heap( int heap_size )
 {
  m_bgn_p = 0;
  initialize( heap_size );
 }

 inline ~sc_byte_heap()
 {
  if ( m_bgn_p ) delete [] m_bgn_p;
 }

};
# 164 "../../../src/systemc/utils/sc_temporary.h"
template<class T>
class sc_vpool {
  protected:
 int m_pool_i;
 T* m_pool_p;
 int m_wrap;

  public:
 inline sc_vpool( int log2, T* pool_p=0 );
 inline ~sc_vpool();
 inline T* allocate();
 inline void reset();
 inline int size();
};

template<class T> sc_vpool<T>::sc_vpool( int log2, T* pool_p )
{

 m_pool_i = 0;
 m_pool_p = pool_p ? pool_p : new T[1 << log2];
 m_wrap = ~(-1 << log2);
}

template<class T> sc_vpool<T>::~sc_vpool()
{

}

template<class T> T* sc_vpool<T>::allocate()
{
 T* result_p;

 result_p = &m_pool_p[m_pool_i];
 m_pool_i = (m_pool_i + 1) & m_wrap;
 return result_p;
}

template<class T> void sc_vpool<T>::reset()
{
 m_pool_i = 0;
}

template<class T> int sc_vpool<T>::size()
{
 return m_wrap + 1;
}
# 83 "../../../src/systemc/datatypes/int/sc_unsigned.h" 2


namespace sc_dt
{


class sc_unsigned_bitref_r;
class sc_unsigned_bitref;
class sc_unsigned_subref_r;
class sc_unsigned_subref;
class sc_concatref;
class sc_unsigned;


class sc_bv_base;
class sc_lv_base;
class sc_int_base;
class sc_uint_base;
class sc_signed;
class sc_signed_subref_r;
class sc_fxval;
class sc_fxval_fast;
class sc_fxnum;
class sc_fxnum_fast;
# 115 "../../../src/systemc/datatypes/int/sc_unsigned.h"
class sc_unsigned_bitref_r : public sc_value_base
{
    friend class sc_unsigned;

protected:



    sc_unsigned_bitref_r( const sc_unsigned& obj_, int index_ )
 : m_obj_p( const_cast<sc_unsigned*>( &obj_ ) ), m_index( index_ )
 {}

public:



    virtual ~sc_unsigned_bitref_r()
 {}



    sc_unsigned_bitref_r( const sc_unsigned_bitref_r& a )
 : m_obj_p( a.m_obj_p ), m_index( a.m_index )
 {}




    sc_unsigned_bitref_r* clone() const
 { return new sc_unsigned_bitref_r( *this ); }




    int length() const
 { return 1; }




    operator bool () const;
    bool operator ! () const;
    bool operator ~ () const;




    bool value() const
 { return operator bool(); }

    bool to_bool() const
 { return operator bool(); }




    virtual int concat_length(bool* xz_present_p) const
        { if ( xz_present_p ) *xz_present_p = false; return 1; }
    virtual uint64 concat_get_uint64() const
        { return (uint64)operator bool(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const
        {
            int bit_mask = 1 << (low_i % 30);
            int word_i = low_i / 30;
     dst_p[word_i] &= ~bit_mask;
     return false;
        }
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const
        {
            int bit_mask = 1 << (low_i % 30);
     bool result;
            int word_i = low_i / 30;
            if ( operator bool() )
     {
                dst_p[word_i] |= bit_mask;
  result = true;
     }
            else
     {
                dst_p[word_i] &= ~bit_mask;
  result = false;
     }
     return result;
        }



    void print( ostream& os = cout ) const
 { os << to_bool(); }

protected:

    sc_unsigned* m_obj_p;
    int m_index;

private:


    sc_unsigned_bitref_r();
    sc_unsigned_bitref_r& operator = ( const sc_unsigned_bitref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_unsigned_bitref_r& );
# 230 "../../../src/systemc/datatypes/int/sc_unsigned.h"
class sc_unsigned_bitref
    : public sc_unsigned_bitref_r
{
    friend class sc_unsigned;




    sc_unsigned_bitref( sc_unsigned& obj_, int index_ )
 : sc_unsigned_bitref_r( obj_, index_ )
 {}

public:



    sc_unsigned_bitref( const sc_unsigned_bitref& a )
 : sc_unsigned_bitref_r( a )
 {}




    sc_unsigned_bitref* clone() const
 { return new sc_unsigned_bitref( *this ); }




    sc_unsigned_bitref& operator = ( const sc_unsigned_bitref_r& );
    sc_unsigned_bitref& operator = ( const sc_unsigned_bitref& );
    sc_unsigned_bitref& operator = ( bool );

    sc_unsigned_bitref& operator &= ( bool );
    sc_unsigned_bitref& operator |= ( bool );
    sc_unsigned_bitref& operator ^= ( bool );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    void scan( istream& is = cin );

private:


    sc_unsigned_bitref();
};



inline
istream&
operator >> ( istream&, sc_unsigned_bitref& );
# 298 "../../../src/systemc/datatypes/int/sc_unsigned.h"
class sc_unsigned_subref_r : public sc_value_base
{
    friend class sc_unsigned;
    friend class sc_unsigned_signal;

protected:



    sc_unsigned_subref_r( const sc_unsigned& obj_, int left_, int right_ )
 : m_obj_p( const_cast<sc_unsigned*>( &obj_ ) ),
   m_left( left_ ), m_right( right_ )
 {}
    sc_unsigned_subref_r()
 {}

public:



    virtual ~sc_unsigned_subref_r()
 {}




    sc_unsigned_subref_r( const sc_unsigned_subref_r& a )
 : m_obj_p( a.m_obj_p ), m_left( a.m_left ), m_right( a.m_right )
 {}




    sc_unsigned_subref_r* clone() const
 { return new sc_unsigned_subref_r( *this ); }




    int length() const
        { return ( m_left - m_right + 1 ); }




    operator sc_unsigned () const;




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;




    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    virtual int concat_length(bool* xz_present_p) const
 {
     if ( xz_present_p ) *xz_present_p = false;
     return m_left - m_right + 1;
 }
    virtual uint64 concat_get_uint64() const;
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;



    bool and_reduce() const;
    bool nand_reduce() const;
    bool or_reduce() const;
    bool nor_reduce() const;
    bool xor_reduce() const ;
    bool xnor_reduce() const;



    void print( ostream& os = cout ) const
 { os << to_string(); }

protected:

    sc_unsigned* m_obj_p;
    int m_left;
    int m_right;

private:


    sc_unsigned_subref_r& operator = ( const sc_unsigned_subref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_unsigned_subref_r& );
# 413 "../../../src/systemc/datatypes/int/sc_unsigned.h"
class sc_unsigned_subref
    : public sc_unsigned_subref_r
{
    friend class sc_unsigned;




    sc_unsigned_subref( sc_unsigned& obj_, int left_, int right_ )
 : sc_unsigned_subref_r( obj_, left_, right_ )
 {}

public:



    sc_unsigned_subref( const sc_unsigned_subref& a )
 : sc_unsigned_subref_r( a )
 {}




    sc_unsigned_subref* clone() const
 { return new sc_unsigned_subref( *this ); }




    sc_unsigned_subref& operator = ( const sc_unsigned_subref_r& a );
    sc_unsigned_subref& operator = ( const sc_unsigned_subref& a );
    sc_unsigned_subref& operator = ( const sc_unsigned& a );

    sc_unsigned_subref& operator = ( const sc_concatref& a );

    sc_unsigned_subref& operator = ( const sc_signed_subref_r& a );
    sc_unsigned_subref& operator = ( const sc_signed& a );

    sc_unsigned_subref& operator = ( const char* a );
    sc_unsigned_subref& operator = ( unsigned long a );
    sc_unsigned_subref& operator = ( long a );

    sc_unsigned_subref& operator = ( unsigned int a )
 { return operator = ( (unsigned long) a ); }

    sc_unsigned_subref& operator = ( int a )
 { return operator = ( (long) a ); }

    sc_unsigned_subref& operator = ( uint64 a );
    sc_unsigned_subref& operator = ( int64 a );
    sc_unsigned_subref& operator = ( double a );
    sc_unsigned_subref& operator = ( const sc_int_base& a );
    sc_unsigned_subref& operator = ( const sc_uint_base& a );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    void scan( istream& is = cin );

private:


    sc_unsigned_subref();
};



inline
istream&
operator >> ( istream&, sc_unsigned_subref& );
# 497 "../../../src/systemc/datatypes/int/sc_unsigned.h"
class sc_unsigned : public sc_value_base
{
 friend class sc_concatref;
    friend class sc_unsigned_bitref_r;
    friend class sc_unsigned_bitref;
    friend class sc_unsigned_subref_r;
    friend class sc_unsigned_subref;
    friend class sc_signed;
    friend class sc_signed_subref;


  typedef bool elemtype;

public:



    explicit sc_unsigned( int nb = sc_length_param().len() );
    sc_unsigned( const sc_unsigned& v );
    sc_unsigned( const sc_signed& v );




    sc_unsigned& operator = (const sc_unsigned& v);
    sc_unsigned& operator = (const sc_unsigned_subref_r& a );

    sc_unsigned& operator = ( const sc_concatref& a );

    sc_unsigned& operator = (const sc_signed& v);
    sc_unsigned& operator = (const sc_signed_subref_r& a );

    sc_unsigned& operator = ( const char* v);
    sc_unsigned& operator = ( int64 v);
    sc_unsigned& operator = ( uint64 v);
    sc_unsigned& operator = ( long v);
    sc_unsigned& operator = ( unsigned long v);

    sc_unsigned& operator = ( int v)
 { return operator=((long) v); }

    sc_unsigned& operator = ( unsigned int v)
 { return operator=((unsigned long) v); }

    sc_unsigned& operator = ( double v);
    sc_unsigned& operator = ( const sc_int_base& v);
    sc_unsigned& operator = ( const sc_uint_base& v);

    sc_unsigned& operator = ( const sc_bv_base& );
    sc_unsigned& operator = ( const sc_lv_base& );


    sc_unsigned& operator = ( const sc_fxval& );
    sc_unsigned& operator = ( const sc_fxval_fast& );
    sc_unsigned& operator = ( const sc_fxnum& );
    sc_unsigned& operator = ( const sc_fxnum_fast& );





    virtual ~sc_unsigned()
 {

         delete [] digit;

 }



 unsigned long* get_raw() const { return digit; }
    virtual int concat_length(bool* xz_present_p) const
       { if ( xz_present_p ) *xz_present_p = false; return nbits-1; }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const;
    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    sc_unsigned& operator ++ ();
    const sc_unsigned operator ++ (int);



    sc_unsigned& operator -- ();
    const sc_unsigned operator -- (int);




    sc_unsigned_bitref operator [] ( int i )
 { return sc_unsigned_bitref( *this, i ); }

    sc_unsigned_bitref_r operator [] ( int i ) const
 { return sc_unsigned_bitref_r( *this, i ); }

    sc_unsigned_bitref bit( int i )
 { return sc_unsigned_bitref( *this, i ); }

    sc_unsigned_bitref_r bit( int i ) const
 { return sc_unsigned_bitref_r( *this, i ); }
# 613 "../../../src/systemc/datatypes/int/sc_unsigned.h"
    sc_unsigned_subref range( int i, int j )
 { return sc_unsigned_subref( *this, i, j ); }

    sc_unsigned_subref_r range( int i, int j ) const
 { return sc_unsigned_subref_r( *this, i, j ); }

    sc_unsigned_subref operator () ( int i, int j )
 { return sc_unsigned_subref( *this, i, j ); }

    sc_unsigned_subref_r operator () ( int i, int j ) const
 { return sc_unsigned_subref_r( *this, i, j ); }




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;
# 646 "../../../src/systemc/datatypes/int/sc_unsigned.h"
    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

    void scan( istream& is = cin );

    void dump( ostream& os = cout ) const;



  int length() const { return nbits - 1; }
  bool iszero() const;
  bool sign() const { return 0; }



    bool and_reduce() const;

    bool nand_reduce() const
        { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
        { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
        { return ( ! xor_reduce() ); }



  bool test(int i) const;
  void set(int i);
  void clear(int i);
  void set(int i, bool v)
    { if (v) set(i); else clear(i); }
  void invert(int i)
    { if (test(i)) clear(i); else set(i); }


  void reverse();


  void get_packed_rep(unsigned long *buf) const;
  void set_packed_rep(unsigned long *buf);
# 732 "../../../src/systemc/datatypes/int/sc_unsigned.h"
  friend sc_signed operator + (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator + (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator + (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator + (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator + (const sc_unsigned& u, uint64 v);
  friend sc_signed operator + (const sc_unsigned& u, long v);
  friend sc_unsigned operator + (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator + (const sc_unsigned& u, int v);
  friend sc_unsigned operator + (const sc_unsigned& u, unsigned int v)
    { return operator+(u, (unsigned long) v); }

  friend sc_signed operator + (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator + (uint64 u, const sc_unsigned& v);
  friend sc_signed operator + (long u, const sc_unsigned& v);
  friend sc_unsigned operator + (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator + (int u, const sc_unsigned& v);
  friend sc_unsigned operator + (unsigned int u, const sc_unsigned& v)
    { return operator+((unsigned long) u, v); }

  sc_unsigned& operator += (const sc_signed& v);
  sc_unsigned& operator += (const sc_unsigned& v);
  sc_unsigned& operator += (int64 v);
  sc_unsigned& operator += (uint64 v);
  sc_unsigned& operator += (long v);
  sc_unsigned& operator += (unsigned long v);
  sc_unsigned& operator += (int v)
    { return operator+=((long) v); }
  sc_unsigned& operator += (unsigned int v)
    { return operator+=((unsigned long) v); }

  friend sc_unsigned operator + (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator + (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator + (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator + (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator += (const sc_int_base& v);
  sc_unsigned& operator += (const sc_uint_base& v);



  friend sc_signed operator - (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator - (const sc_signed& u, const sc_unsigned& v);

  friend sc_signed operator - (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator - (const sc_unsigned& u, int64 v);
  friend sc_signed operator - (const sc_unsigned& u, uint64 v);
  friend sc_signed operator - (const sc_unsigned& u, long v);
  friend sc_signed operator - (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator - (const sc_unsigned& u, int v);
  friend sc_signed operator - (const sc_unsigned& u, unsigned int v);

  friend sc_signed operator - (int64 u, const sc_unsigned& v);
  friend sc_signed operator - (uint64 u, const sc_unsigned& v);
  friend sc_signed operator - (long u, const sc_unsigned& v);
  friend sc_signed operator - (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator - (int u, const sc_unsigned& v);
  friend sc_signed operator - (unsigned int u, const sc_unsigned& v);

  sc_unsigned& operator -= (const sc_signed& v);
  sc_unsigned& operator -= (const sc_unsigned& v);
  sc_unsigned& operator -= (int64 v);
  sc_unsigned& operator -= (uint64 v);
  sc_unsigned& operator -= (long v);
  sc_unsigned& operator -= (unsigned long v);
  sc_unsigned& operator -= (int v)
    { return operator-=((long) v); }
  sc_unsigned& operator -= (unsigned int v)
    { return operator-=((unsigned long) v); }

  friend sc_signed operator - (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator - (const sc_unsigned& u, const sc_int_base& v);
  friend sc_signed operator - (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator - (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator -= (const sc_int_base& v);
  sc_unsigned& operator -= (const sc_uint_base& v);



  friend sc_signed operator * (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator * (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator * (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator * (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator * (const sc_unsigned& u, uint64 v);
  friend sc_signed operator * (const sc_unsigned& u, long v);
  friend sc_unsigned operator * (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator * (const sc_unsigned& u, int v);
  friend sc_unsigned operator * (const sc_unsigned& u, unsigned int v)
    { return operator*(u, (unsigned long) v); }

  friend sc_signed operator * (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator * (uint64 u, const sc_unsigned& v);
  friend sc_signed operator * (long u, const sc_unsigned& v);
  friend sc_unsigned operator * (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator * (int u, const sc_unsigned& v);
  friend sc_unsigned operator * (unsigned int u, const sc_unsigned& v)
    { return operator*((unsigned long) u, v); }

  sc_unsigned& operator *= (const sc_signed& v);
  sc_unsigned& operator *= (const sc_unsigned& v);
  sc_unsigned& operator *= (int64 v);
  sc_unsigned& operator *= (uint64 v);
  sc_unsigned& operator *= (long v);
  sc_unsigned& operator *= (unsigned long v);
  sc_unsigned& operator *= (int v)
    { return operator*=((long) v); }
  sc_unsigned& operator *= (unsigned int v)
    { return operator*=((unsigned long) v); }

  friend sc_unsigned operator * (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator * (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator * (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator * (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator *= (const sc_int_base& v);
  sc_unsigned& operator *= (const sc_uint_base& v);



  friend sc_signed operator / (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator / (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator / (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator / (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator / (const sc_unsigned& u, uint64 v);
  friend sc_signed operator / (const sc_unsigned& u, long v);
  friend sc_unsigned operator / (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator / (const sc_unsigned& u, int v);
  friend sc_unsigned operator / (const sc_unsigned& u, unsigned int v)
    { return operator/(u, (unsigned long) v); }

  friend sc_signed operator / (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator / (uint64 u, const sc_unsigned& v);
  friend sc_signed operator / (long u, const sc_unsigned& v);
  friend sc_unsigned operator / (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator / (int u, const sc_unsigned& v);
  friend sc_unsigned operator / (unsigned int u, const sc_unsigned& v)
    { return operator/((unsigned long) u, v); }

  sc_unsigned& operator /= (const sc_signed& v);
  sc_unsigned& operator /= (const sc_unsigned& v);
  sc_unsigned& operator /= (int64 v);
  sc_unsigned& operator /= (uint64 v);
  sc_unsigned& operator /= (long v);
  sc_unsigned& operator /= (unsigned long v);
  sc_unsigned& operator /= (int v)
    { return operator/=((long) v); }
  sc_unsigned& operator /= (unsigned int v)
    { return operator/=((unsigned long) v); }

  friend sc_unsigned operator / (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator / (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator / (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator / (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator /= (const sc_int_base& v);
  sc_unsigned& operator /= (const sc_uint_base& v);



  friend sc_signed operator % (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator % (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator % (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator % (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator % (const sc_unsigned& u, uint64 v);
  friend sc_signed operator % (const sc_unsigned& u, long v);
  friend sc_unsigned operator % (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator % (const sc_unsigned& u, int v);
  friend sc_unsigned operator % (const sc_unsigned& u, unsigned int v)
    { return operator%(u, (unsigned long) v); }

  friend sc_signed operator % (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator % (uint64 u, const sc_unsigned& v);
  friend sc_signed operator % (long u, const sc_unsigned& v);
  friend sc_unsigned operator % (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator % (int u, const sc_unsigned& v);
  friend sc_unsigned operator % (unsigned int u, const sc_unsigned& v)
    { return operator%((unsigned long) u, v); }

  sc_unsigned& operator %= (const sc_signed& v);
  sc_unsigned& operator %= (const sc_unsigned& v);
  sc_unsigned& operator %= (int64 v);
  sc_unsigned& operator %= (uint64 v);
  sc_unsigned& operator %= (long v);
  sc_unsigned& operator %= (unsigned long v);
  sc_unsigned& operator %= (int v)
    { return operator%=((long) v); }
  sc_unsigned& operator %= (unsigned int v)
    { return operator%=((unsigned long) v); }

  friend sc_unsigned operator % (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator % (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator % (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator % (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator %= (const sc_int_base& v);
  sc_unsigned& operator %= (const sc_uint_base& v);





  friend sc_signed operator & (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator & (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator & (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator & (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator & (const sc_unsigned& u, uint64 v);
  friend sc_signed operator & (const sc_unsigned& u, long v);
  friend sc_unsigned operator & (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator & (const sc_unsigned& u, int v);
  friend sc_unsigned operator & (const sc_unsigned& u, unsigned int v)
    { return operator&(u, (unsigned long) v); }

  friend sc_signed operator & (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator & (uint64 u, const sc_unsigned& v);
  friend sc_signed operator & (long u, const sc_unsigned& v);
  friend sc_unsigned operator & (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator & (int u, const sc_unsigned& v);
  friend sc_unsigned operator & (unsigned int u, const sc_unsigned& v)
    { return operator&((unsigned long) u, v); }

  sc_unsigned& operator &= (const sc_signed& v);
  sc_unsigned& operator &= (const sc_unsigned& v);
  sc_unsigned& operator &= (int64 v);
  sc_unsigned& operator &= (uint64 v);
  sc_unsigned& operator &= (long v);
  sc_unsigned& operator &= (unsigned long v);
  sc_unsigned& operator &= (int v)
    { return operator&=((long) v); }
  sc_unsigned& operator &= (unsigned int v)
    { return operator&=((unsigned long) v); }

  friend sc_unsigned operator & (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator & (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator & (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator & (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator &= (const sc_int_base& v);
  sc_unsigned& operator &= (const sc_uint_base& v);



  friend sc_signed operator | (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator | (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator | (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator | (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator | (const sc_unsigned& u, uint64 v);
  friend sc_signed operator | (const sc_unsigned& u, long v);
  friend sc_unsigned operator | (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator | (const sc_unsigned& u, int v);
  friend sc_unsigned operator | (const sc_unsigned& u, unsigned int v)
    { return operator|(u, (unsigned long) v); }

  friend sc_signed operator | (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator | (uint64 u, const sc_unsigned& v);
  friend sc_signed operator | (long u, const sc_unsigned& v);
  friend sc_unsigned operator | (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator | (int u, const sc_unsigned& v);
  friend sc_unsigned operator | (unsigned int u, const sc_unsigned& v)
    { return operator|((unsigned long) u, v); }

  sc_unsigned& operator |= (const sc_signed& v);
  sc_unsigned& operator |= (const sc_unsigned& v);
  sc_unsigned& operator |= (int64 v);
  sc_unsigned& operator |= (uint64 v);
  sc_unsigned& operator |= (long v);
  sc_unsigned& operator |= (unsigned long v);
  sc_unsigned& operator |= (int v)
    { return operator|=((long) v); }
  sc_unsigned& operator |= (unsigned int v)
    { return operator|=((unsigned long) v); }

  friend sc_unsigned operator | (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator | (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator | (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator | (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator |= (const sc_int_base& v);
  sc_unsigned& operator |= (const sc_uint_base& v);



  friend sc_signed operator ^ (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator ^ (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator ^ (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_signed operator ^ (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator ^ (const sc_unsigned& u, uint64 v);
  friend sc_signed operator ^ (const sc_unsigned& u, long v);
  friend sc_unsigned operator ^ (const sc_unsigned& u, unsigned long v);
  friend sc_signed operator ^ (const sc_unsigned& u, int v);
  friend sc_unsigned operator ^ (const sc_unsigned& u, unsigned int v)
    { return operator^(u, (unsigned long) v); }

  friend sc_signed operator ^ (int64 u, const sc_unsigned& v);
  friend sc_unsigned operator ^ (uint64 u, const sc_unsigned& v);
  friend sc_signed operator ^ (long u, const sc_unsigned& v);
  friend sc_unsigned operator ^ (unsigned long u, const sc_unsigned& v);
  friend sc_signed operator ^ (int u, const sc_unsigned& v);
  friend sc_unsigned operator ^ (unsigned int u, const sc_unsigned& v)
    { return operator^((unsigned long) u, v); }

  sc_unsigned& operator ^= (const sc_signed& v);
  sc_unsigned& operator ^= (const sc_unsigned& v);
  sc_unsigned& operator ^= (int64 v);
  sc_unsigned& operator ^= (uint64 v);
  sc_unsigned& operator ^= (long v);
  sc_unsigned& operator ^= (unsigned long v);
  sc_unsigned& operator ^= (int v)
    { return operator^=((long) v); }
  sc_unsigned& operator ^= (unsigned int v)
    { return operator^=((unsigned long) v); }

  friend sc_unsigned operator ^ (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_signed operator ^ (const sc_unsigned& u, const sc_int_base& v);
  friend sc_unsigned operator ^ (const sc_uint_base& u, const sc_unsigned& v);
  friend sc_signed operator ^ (const sc_int_base& u, const sc_unsigned& v);
  sc_unsigned& operator ^= (const sc_int_base& v);
  sc_unsigned& operator ^= (const sc_uint_base& v);





  friend sc_unsigned operator << (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator << (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator << (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_unsigned operator << (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator << (const sc_unsigned& u, uint64 v);
  friend sc_unsigned operator << (const sc_unsigned& u, long v);
  friend sc_unsigned operator << (const sc_unsigned& u, unsigned long v);
  friend sc_unsigned operator << (const sc_unsigned& u, int v)
    { return operator<<(u, (long) v); }
  friend sc_unsigned operator << (const sc_unsigned& u, unsigned int v)
    { return operator<<(u, (unsigned long) v); }

  sc_unsigned& operator <<= (const sc_signed& v);
  sc_unsigned& operator <<= (const sc_unsigned& v);
  sc_unsigned& operator <<= (int64 v);
  sc_unsigned& operator <<= (uint64 v);
  sc_unsigned& operator <<= (long v);
  sc_unsigned& operator <<= (unsigned long v);
  sc_unsigned& operator <<= (int v)
    { return operator<<=((long) v); }
  sc_unsigned& operator <<= (unsigned int v)
    { return operator<<=((unsigned long) v); }

  friend sc_unsigned operator << (const sc_unsigned& u, const sc_uint_base& v);
  friend sc_unsigned operator << (const sc_unsigned& u, const sc_int_base& v);
  sc_unsigned& operator <<= (const sc_int_base& v);
  sc_unsigned& operator <<= (const sc_uint_base& v);



  friend sc_unsigned operator >> (const sc_unsigned& u, const sc_signed& v);
  friend sc_signed operator >> (const sc_signed& u, const sc_unsigned& v);

  friend sc_unsigned operator >> (const sc_unsigned& u, const sc_unsigned& v);
  friend sc_unsigned operator >> (const sc_unsigned& u, int64 v);
  friend sc_unsigned operator >> (const sc_unsigned& u, uint64 v);
  friend sc_unsigned operator >> (const sc_unsigned& u, long v);
  friend sc_unsigned operator >> (const sc_unsigned& u, unsigned long v);
  friend sc_unsigned operator >> (const sc_unsigned& u, int v)
    { return operator>>(u, (long) v); }
  friend sc_unsigned operator >> (const sc_unsigned& u, unsigned int v)
    { return operator>>(u, (unsigned long) v); }

  sc_unsigned& operator >>= (const sc_signed& v);
  sc_unsigned& operator >>= (const sc_unsigned& v);
  sc_unsigned& operator >>= (int64 v);
  sc_unsigned& operator >>= (uint64 v);
  sc_unsigned& operator >>= (long v);
  sc_unsigned& operator >>= (unsigned long v);
  sc_unsigned& operator >>= (int v)
    { return operator>>=((long) v); }
  sc_unsigned& operator >>= (unsigned int v)
    { return operator>>=((unsigned long) v); }

  friend sc_unsigned operator >> ( const sc_unsigned& , const sc_uint_base& );
  friend sc_unsigned operator >> ( const sc_unsigned&, const sc_int_base& );
  sc_unsigned& operator >>= (const sc_int_base& v);
  sc_unsigned& operator >>= (const sc_uint_base& v);


  friend sc_unsigned operator + (const sc_unsigned& u);
  friend sc_signed operator - (const sc_unsigned& u);





  friend bool operator == (const sc_unsigned& u, const sc_signed& v);
  friend bool operator == (const sc_signed& u, const sc_unsigned& v);

  friend bool operator == (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator == (const sc_unsigned& u, int64 v);
  friend bool operator == (const sc_unsigned& u, uint64 v);
  friend bool operator == (const sc_unsigned& u, long v);
  friend bool operator == (const sc_unsigned& u, unsigned long v);
  friend bool operator == (const sc_unsigned& u, int v)
    { return operator==(u, (long) v); }
  friend bool operator == (const sc_unsigned& u, unsigned int v)
    { return operator==(u, (unsigned long) v); }

  friend bool operator == (int64 u, const sc_unsigned& v);
  friend bool operator == (uint64 u, const sc_unsigned& v);
  friend bool operator == (long u, const sc_unsigned& v);
  friend bool operator == (unsigned long u, const sc_unsigned& v);
  friend bool operator == (int u, const sc_unsigned& v)
    { return operator==((long) u, v); }
  friend bool operator == (unsigned int u, const sc_unsigned& v)
    { return operator==((unsigned long) u, v); }

  friend bool operator == (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator == (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator == (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator == (const sc_int_base& u, const sc_unsigned& v);



  friend bool operator != (const sc_unsigned& u, const sc_signed& v);
  friend bool operator != (const sc_signed& u, const sc_unsigned& v);

  friend bool operator != (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator != (const sc_unsigned& u, int64 v);
  friend bool operator != (const sc_unsigned& u, uint64 v);
  friend bool operator != (const sc_unsigned& u, long v);
  friend bool operator != (const sc_unsigned& u, unsigned long v);
  friend bool operator != (const sc_unsigned& u, int v)
    { return operator!=(u, (long) v); }
  friend bool operator != (const sc_unsigned& u, unsigned int v)
    { return operator!=(u, (unsigned long) v); }

  friend bool operator != (int64 u, const sc_unsigned& v);
  friend bool operator != (uint64 u, const sc_unsigned& v);
  friend bool operator != (long u, const sc_unsigned& v);
  friend bool operator != (unsigned long u, const sc_unsigned& v);
  friend bool operator != (int u, const sc_unsigned& v)
    { return operator!=((long) u, v); }
  friend bool operator != (unsigned int u, const sc_unsigned& v)
    { return operator!=((unsigned long) u, v); }

  friend bool operator != (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator != (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator != (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator != (const sc_int_base& u, const sc_unsigned& v);



  friend bool operator < (const sc_unsigned& u, const sc_signed& v);
  friend bool operator < (const sc_signed& u, const sc_unsigned& v);

  friend bool operator < (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator < (const sc_unsigned& u, int64 v);
  friend bool operator < (const sc_unsigned& u, uint64 v);
  friend bool operator < (const sc_unsigned& u, long v);
  friend bool operator < (const sc_unsigned& u, unsigned long v);
  friend bool operator < (const sc_unsigned& u, int v)
    { return operator<(u, (long) v); }
  friend bool operator < (const sc_unsigned& u, unsigned int v)
    { return operator<(u, (unsigned long) v); }

  friend bool operator < (int64 u, const sc_unsigned& v);
  friend bool operator < (uint64 u, const sc_unsigned& v);
  friend bool operator < (long u, const sc_unsigned& v);
  friend bool operator < (unsigned long u, const sc_unsigned& v);
  friend bool operator < (int u, const sc_unsigned& v)
    { return operator<((long) u, v); }
  friend bool operator < (unsigned int u, const sc_unsigned& v)
    { return operator<((unsigned long) u, v); }

  friend bool operator < (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator < (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator < (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator < (const sc_int_base& u, const sc_unsigned& v);



  friend bool operator <= (const sc_unsigned& u, const sc_signed& v);
  friend bool operator <= (const sc_signed& u, const sc_unsigned& v);

  friend bool operator <= (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator <= (const sc_unsigned& u, int64 v);
  friend bool operator <= (const sc_unsigned& u, uint64 v);
  friend bool operator <= (const sc_unsigned& u, long v);
  friend bool operator <= (const sc_unsigned& u, unsigned long v);
  friend bool operator <= (const sc_unsigned& u, int v)
    { return operator<=(u, (long) v); }
  friend bool operator <= (const sc_unsigned& u, unsigned int v)
    { return operator<=(u, (unsigned long) v); }

  friend bool operator <= (int64 u, const sc_unsigned& v);
  friend bool operator <= (uint64 u, const sc_unsigned& v);
  friend bool operator <= (long u, const sc_unsigned& v);
  friend bool operator <= (unsigned long u, const sc_unsigned& v);
  friend bool operator <= (int u, const sc_unsigned& v)
    { return operator<=((long) u, v); }
  friend bool operator <= (unsigned int u, const sc_unsigned& v)
    { return operator<=((unsigned long) u, v); }

  friend bool operator <= (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator <= (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator <= (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator <= (const sc_int_base& u, const sc_unsigned& v);



  friend bool operator > (const sc_unsigned& u, const sc_signed& v);
  friend bool operator > (const sc_signed& u, const sc_unsigned& v);

  friend bool operator > (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator > (const sc_unsigned& u, int64 v);
  friend bool operator > (const sc_unsigned& u, uint64 v);
  friend bool operator > (const sc_unsigned& u, long v);
  friend bool operator > (const sc_unsigned& u, unsigned long v);
  friend bool operator > (const sc_unsigned& u, int v)
    { return operator>(u, (long) v); }
  friend bool operator > (const sc_unsigned& u, unsigned int v)
    { return operator>(u, (unsigned long) v); }

  friend bool operator > (int64 u, const sc_unsigned& v);
  friend bool operator > (uint64 u, const sc_unsigned& v);
  friend bool operator > (long u, const sc_unsigned& v);
  friend bool operator > (unsigned long u, const sc_unsigned& v);
  friend bool operator > (int u, const sc_unsigned& v)
    { return operator>((long) u, v); }
  friend bool operator > (unsigned int u, const sc_unsigned& v)
    { return operator>((unsigned long) u, v); }

  friend bool operator > (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator > (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator > (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator > (const sc_int_base& u, const sc_unsigned& v);



  friend bool operator >= (const sc_unsigned& u, const sc_signed& v);
  friend bool operator >= (const sc_signed& u, const sc_unsigned& v);

  friend bool operator >= (const sc_unsigned& u, const sc_unsigned& v);
  friend bool operator >= (const sc_unsigned& u, int64 v);
  friend bool operator >= (const sc_unsigned& u, uint64 v);
  friend bool operator >= (const sc_unsigned& u, long v);
  friend bool operator >= (const sc_unsigned& u, unsigned long v);
  friend bool operator >= (const sc_unsigned& u, int v)
    { return operator>=(u, (long) v); }
  friend bool operator >= (const sc_unsigned& u, unsigned int v)
    { return operator>=(u, (unsigned long) v); }

  friend bool operator >= (int64 u, const sc_unsigned& v);
  friend bool operator >= (uint64 u, const sc_unsigned& v);
  friend bool operator >= (long u, const sc_unsigned& v);
  friend bool operator >= (unsigned long u, const sc_unsigned& v);
  friend bool operator >= (int u, const sc_unsigned& v)
    { return operator>=((long) u, v); }
  friend bool operator >= (unsigned int u, const sc_unsigned& v)
    { return operator>=((unsigned long) u, v); }

  friend bool operator >= (const sc_unsigned& u, const sc_uint_base& v);
  friend bool operator >= (const sc_unsigned& u, const sc_int_base& v);
  friend bool operator >= (const sc_uint_base& u, const sc_unsigned& v);
  friend bool operator >= (const sc_int_base& u, const sc_unsigned& v);


  friend sc_unsigned operator ~ (const sc_unsigned& u);


  friend int compare_unsigned(small_type us,
                              int unb,
                              int und,
                              const unsigned long *ud,
                              small_type vs,
                              int vnb,
                              int vnd,
                              const unsigned long *vd,
                              small_type if_u_signed = 0,
                              small_type if_v_signed = 0);

  friend sc_unsigned add_unsigned_friend(small_type us,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         small_type vs,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned sub_unsigned_friend(small_type us,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         small_type vs,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned mul_unsigned_friend(small_type s,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned div_unsigned_friend(small_type s,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned mod_unsigned_friend(small_type us,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned and_unsigned_friend(small_type us,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         small_type vs,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

  friend sc_unsigned or_unsigned_friend(small_type us,
                                        int unb,
                                        int und,
                                        const unsigned long *ud,
                                        small_type vs,
                                        int vnb,
                                        int vnd,
                                        const unsigned long *vd);

  friend sc_unsigned xor_unsigned_friend(small_type us,
                                         int unb,
                                         int und,
                                         const unsigned long *ud,
                                         small_type vs,
                                         int vnb,
                                         int vnd,
                                         const unsigned long *vd);

public:
  static sc_vpool<sc_unsigned> m_pool;

private:

  small_type sgn;
  int nbits;
  int ndigits;




  unsigned long *digit;





  sc_unsigned(const sc_unsigned& v, small_type s);
  sc_unsigned(const sc_signed& v, small_type s);


  sc_unsigned(small_type s, int nb, int nd,
              unsigned long *d, bool alloc = true);


  sc_unsigned(const sc_unsigned* u, int l, int r);



  small_type default_sign() const
    { return 1; }

  int num_bits(int nb) const { return nb + 1; }

  bool check_if_outside(int bit_num) const;

  void copy_digits(int nb, int nd, const unsigned long *d)
    { copy_digits_unsigned(sgn, nbits, ndigits, digit, nb, nd, d); }

  void makezero()
    { sgn = make_zero(ndigits, digit); }



  void convert_2C_to_SM()
    { sgn = convert_unsigned_2C_to_SM(nbits, ndigits, digit); }

  void convert_SM_to_2C_to_SM()
    { sgn = convert_unsigned_SM_to_2C_to_SM(sgn, nbits, ndigits, digit); }

  void convert_SM_to_2C()
    { convert_unsigned_SM_to_2C(sgn, ndigits, digit); }

};



inline
ostream&
operator << ( ostream&, const sc_unsigned& );

inline
istream&
operator >> ( istream&, sc_unsigned& );
# 1454 "../../../src/systemc/datatypes/int/sc_unsigned.h"
inline
ostream&
operator << ( ostream& os, const sc_unsigned_bitref_r& a )
{
    a.print( os );
    return os;
}
# 1470 "../../../src/systemc/datatypes/int/sc_unsigned.h"
inline
istream&
operator >> ( istream& is, sc_unsigned_bitref& a )
{
    a.scan( is );
    return is;
}
# 1487 "../../../src/systemc/datatypes/int/sc_unsigned.h"
inline bool sc_unsigned_subref_r::and_reduce() const
{
   const sc_unsigned* target_p = m_obj_p;
   for ( int i = m_right; i <= m_left; i++ )
 if ( !target_p->test(i) ) return false;
   return true;
}

inline bool sc_unsigned_subref_r::nand_reduce() const
{
    return !and_reduce();
}

inline bool sc_unsigned_subref_r::or_reduce() const
{
   const sc_unsigned* target_p = m_obj_p;
   for ( int i = m_right; i <= m_left; i++ )
 if ( target_p->test(i) ) return true;
   return false;
}

inline bool sc_unsigned_subref_r::nor_reduce() const
{
    return !or_reduce();
}

inline bool sc_unsigned_subref_r::xor_reduce() const
{
   int odd;
   const sc_unsigned* target_p = m_obj_p;
   odd = 0;
   for ( int i = m_right; i <= m_left; i++ )
 if ( target_p->test(i) ) odd = ~odd;
   return odd ? true : false;
}

inline bool sc_unsigned_subref_r::xnor_reduce() const
{
    return !xor_reduce();
}


inline
ostream&
operator << ( ostream& os, const sc_unsigned_subref_r& a )
{
    a.print( os );
    return os;
}
# 1546 "../../../src/systemc/datatypes/int/sc_unsigned.h"
inline
sc_unsigned_subref&
sc_unsigned_subref::operator = ( const char* a )
{
    sc_unsigned aa( length() );
    return ( *this = aa = a );
}


inline
istream&
operator >> ( istream& is, sc_unsigned_subref& a )
{
    a.scan( is );
    return is;
}
# 1572 "../../../src/systemc/datatypes/int/sc_unsigned.h"
inline
ostream&
operator << ( ostream& os, const sc_unsigned& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_unsigned& a )
{
    a.scan( is );
    return is;
}


}
# 52 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_int_base.h" 1
# 63 "../../../src/systemc/datatypes/int/sc_int_base.h"
namespace sc_dt
{

class sc_concatref;


class sc_int_bitref_r;
class sc_int_bitref;
class sc_int_subref_r;
class sc_int_subref;
class sc_int_base;


class sc_bv_base;
class sc_lv_base;
class sc_signed;
class sc_unsigned;
class sc_fxval;
class sc_fxval_fast;
class sc_fxnum;
class sc_fxnum_fast;


extern const uint_type mask_int[64][64];
# 96 "../../../src/systemc/datatypes/int/sc_int_base.h"
class sc_int_bitref_r : public sc_value_base
{
    friend class sc_int_base;

protected:



    sc_int_bitref_r( const sc_int_base& obj_, int index_ )
        : m_obj_p( const_cast<sc_int_base*>( &obj_ ) ), m_index( index_ )
        {}

public:



    sc_int_bitref_r( const sc_int_bitref_r& a )
        : m_obj_p( a.m_obj_p ), m_index( a.m_index )
        {}



    virtual ~sc_int_bitref_r()
 {}



    sc_int_bitref_r* clone() const
        { return new sc_int_bitref_r( *this ); }




    int length() const
 { return 1; }
# 139 "../../../src/systemc/datatypes/int/sc_int_base.h"
    virtual int concat_length( bool *xz_present_p ) const
 { if (xz_present_p) *xz_present_p = false; return 1; }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const
        {
     int bit_mask = 1 << (low_i % 30);
     int word_i = low_i / 30;

     dst_p[word_i] &= ~bit_mask;
     return false;
 }
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const
        {
     bool non_zero;
     int bit_mask = 1 << (low_i % 30);
     int word_i = low_i / 30;

     if ( operator bool() )
     {
  dst_p[word_i] |= bit_mask;
  non_zero = true;
     }
     else
     {
  dst_p[word_i] &= ~bit_mask;
  non_zero = false;
     }
     return non_zero;
 }
    virtual uint64 concat_get_uint64() const
 { return (uint64)operator bool(); }






    operator bool () const;
    bool operator ! () const;
    bool operator ~ () const;




    bool value() const
 { return operator bool(); }

    bool to_bool() const
 { return operator bool(); }




    void print( ostream& os = cout ) const
 { os << to_bool(); }

protected:

    sc_int_base* m_obj_p;
    int m_index;

private:


    sc_int_bitref_r();
    sc_int_bitref_r& operator = ( const sc_int_bitref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_int_bitref_r& );
# 219 "../../../src/systemc/datatypes/int/sc_int_base.h"
class sc_int_bitref
    : public sc_int_bitref_r
{
    friend class sc_int_base;




    sc_int_bitref( sc_int_base& obj_, int index_ )
 : sc_int_bitref_r( obj_, index_ )
        {}

public:



    sc_int_bitref( const sc_int_bitref& a )
 : sc_int_bitref_r( a )
        {}




    sc_int_bitref* clone() const
        { return new sc_int_bitref( *this ); }




    sc_int_bitref& operator = ( const sc_int_bitref_r& b );
    sc_int_bitref& operator = ( const sc_int_bitref& b );
    sc_int_bitref& operator = ( bool b );

    sc_int_bitref& operator &= ( bool b );
    sc_int_bitref& operator |= ( bool b );
    sc_int_bitref& operator ^= ( bool b );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    void scan( istream& is = cin );

private:


    sc_int_bitref();
};



inline
istream&
operator >> ( istream&, sc_int_bitref& );
# 287 "../../../src/systemc/datatypes/int/sc_int_base.h"
class sc_int_subref_r : public sc_value_base
{
    friend class sc_int_base;
    friend class sc_int_signal;

protected:



    sc_int_subref_r( const sc_int_base& obj_, int left_, int right_ )
        : m_obj_p( const_cast<sc_int_base*>( &obj_ ) ),
   m_left( left_ ), m_right( right_ )
        {}
    sc_int_subref_r()
 {}


public:



    sc_int_subref_r( const sc_int_subref_r& a )
        : m_obj_p( a.m_obj_p ), m_left( a.m_left ), m_right( a.m_right )
        {}



    virtual ~sc_int_subref_r()
 {}



    sc_int_subref_r* clone() const
        { return new sc_int_subref_r( *this ); }




    int length() const
        { return ( m_left - m_right + 1 ); }
# 335 "../../../src/systemc/datatypes/int/sc_int_base.h"
    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return length(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const
    {
 int len = length();
 uint64 val = operator uint_type();
 if ( len < 64 )
     return (uint64)(val & ~((uint_type)-1 << len));
 else
     return (uint64)val;
    }



    bool and_reduce() const;

    bool nand_reduce() const
 { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
 { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
 { return ( ! xor_reduce() ); }




    operator uint_type () const;




    uint_type value() const
 { return operator uint_type(); }


    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;




    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

protected:

    sc_int_base* m_obj_p;
    int m_left;
    int m_right;

private:


    sc_int_subref_r& operator = ( const sc_int_subref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_int_subref_r& );
# 423 "../../../src/systemc/datatypes/int/sc_int_base.h"
class sc_int_subref
    : public sc_int_subref_r
{
    friend class sc_int_base;




    sc_int_subref( sc_int_base& obj_, int left_, int right_ )
 : sc_int_subref_r( obj_, left_, right_ )
        {}

public:



    sc_int_subref( const sc_int_subref& a )
 : sc_int_subref_r( a )
        {}




    sc_int_subref* clone() const
        { return new sc_int_subref( *this ); }




    sc_int_subref& operator = ( int_type v );
    sc_int_subref& operator = ( const sc_int_base& a );

    sc_int_subref& operator = ( const sc_int_subref_r& a )
 { return operator = ( a.operator uint_type() ); }

    sc_int_subref& operator = ( const sc_int_subref& a )
 { return operator = ( a.operator uint_type() ); }

    sc_int_subref& operator = ( const sc_concatref& a );

    sc_int_subref& operator = ( const char* a );

    sc_int_subref& operator = ( unsigned long a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( long a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( unsigned int a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( int a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( uint64 a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( double a )
 { return operator = ( (int_type) a ); }

    sc_int_subref& operator = ( const sc_signed& );
    sc_int_subref& operator = ( const sc_unsigned& );
    sc_int_subref& operator = ( const sc_bv_base& );
    sc_int_subref& operator = ( const sc_lv_base& );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    void scan( istream& is = cin );

private:


    sc_int_subref();
};



inline
istream&
operator >> ( istream&, sc_int_subref& );
# 518 "../../../src/systemc/datatypes/int/sc_int_base.h"
class sc_int_base : public sc_value_base
{
    friend class sc_int_bitref_r;
    friend class sc_int_bitref;
    friend class sc_int_subref_r;
    friend class sc_int_subref;




    void invalid_length() const;
    void invalid_index( int i ) const;
    void invalid_range( int l, int r ) const;

    void check_length() const
 { if( m_len <= 0 || m_len > 64 ) { invalid_length(); } }

    void check_index( int i ) const
 { if( i < 0 || i >= m_len ) { invalid_index( i ); } }

    void check_range( int l, int r ) const
 { if( r < 0 || l >= m_len || l < r ) { invalid_range( l, r ); } }

    void check_value() const;

    void extend_sign()
 {



     m_val = ( m_val << m_ulen >> m_ulen );
 }

public:



    explicit sc_int_base( int w = sc_length_param().len() )
 : m_val( 0 ), m_len( w ), m_ulen( 64 - m_len )
 { check_length(); }

    sc_int_base( int_type v, int w )
 : m_val( v ), m_len( w ), m_ulen( 64 - m_len )
 { check_length(); extend_sign(); }

    sc_int_base( const sc_int_base& a )
 : m_val( a.m_val ), m_len( a.m_len ), m_ulen( a.m_ulen )
 {}

    explicit sc_int_base( const sc_int_subref_r& a )
        : m_val( a ), m_len( a.length() ), m_ulen( 64 - m_len )
        { extend_sign(); }

    explicit sc_int_base( const sc_concatref& a );





    explicit sc_int_base( const sc_signed& a );
    explicit sc_int_base( const sc_unsigned& a );




    virtual ~sc_int_base()
 {}



    sc_int_base& operator = ( int_type v )
 { m_val = v; extend_sign(); return *this; }

    sc_int_base& operator = ( const sc_int_base& a )
 { m_val = a.m_val; extend_sign(); return *this; }

    sc_int_base& operator = ( const sc_int_subref_r& a )
        { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( const sc_concatref& a );


    sc_int_base& operator = ( const sc_signed& a );
    sc_int_base& operator = ( const sc_unsigned& a );


    sc_int_base& operator = ( const sc_fxval& a );
    sc_int_base& operator = ( const sc_fxval_fast& a );
    sc_int_base& operator = ( const sc_fxnum& a );
    sc_int_base& operator = ( const sc_fxnum_fast& a );


    sc_int_base& operator = ( const sc_bv_base& a );
    sc_int_base& operator = ( const sc_lv_base& a );

    sc_int_base& operator = ( const char* a );

    sc_int_base& operator = ( unsigned long a )
 { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( long a )
 { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( unsigned int a )
 { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( int a )
 { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( uint64 a )
 { m_val = a; extend_sign(); return *this; }

    sc_int_base& operator = ( double a )
 { m_val = (int_type) a; extend_sign(); return *this; }




    sc_int_base& operator += ( int_type v )
 { m_val += v; extend_sign(); return *this; }

    sc_int_base& operator -= ( int_type v )
 { m_val -= v; extend_sign(); return *this; }

    sc_int_base& operator *= ( int_type v )
 { m_val *= v; extend_sign(); return *this; }

    sc_int_base& operator /= ( int_type v )
 { m_val /= v; extend_sign(); return *this; }

    sc_int_base& operator %= ( int_type v )
 { m_val %= v; extend_sign(); return *this; }




    sc_int_base& operator &= ( int_type v )
 { m_val &= v; extend_sign(); return *this; }

    sc_int_base& operator |= ( int_type v )
 { m_val |= v; extend_sign(); return *this; }

    sc_int_base& operator ^= ( int_type v )
 { m_val ^= v; extend_sign(); return *this; }


    sc_int_base& operator <<= ( int_type v )
 { m_val <<= v; extend_sign(); return *this; }

    sc_int_base& operator >>= ( int_type v )
 { m_val >>= v; return *this; }




    sc_int_base& operator ++ ()
 { ++ m_val; extend_sign(); return *this; }

    const sc_int_base operator ++ ( int )
 { sc_int_base tmp( *this ); ++ m_val; extend_sign(); return tmp; }

    sc_int_base& operator -- ()
 { -- m_val; extend_sign(); return *this; }

    const sc_int_base operator -- ( int )
 { sc_int_base tmp( *this ); -- m_val; extend_sign(); return tmp; }




    friend bool operator == ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val == b.m_val; }

    friend bool operator != ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val != b.m_val; }

    friend bool operator < ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val < b.m_val; }

    friend bool operator <= ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val <= b.m_val; }

    friend bool operator > ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val > b.m_val; }

    friend bool operator >= ( const sc_int_base& a, const sc_int_base& b )
 { return a.m_val >= b.m_val; }




    sc_int_bitref operator [] ( int i );
    sc_int_bitref_r operator [] ( int i ) const;

    sc_int_bitref bit( int i );
    sc_int_bitref_r bit( int i ) const;




    sc_int_subref operator () ( int left, int right );
    sc_int_subref_r operator () ( int left, int right ) const;

    sc_int_subref range( int left, int right );
    sc_int_subref_r range( int left, int right ) const;




    bool test( int i ) const
 { return ( 0 != (m_val & (UINT_ONE << i)) ); }

    void set( int i )
 { m_val |= (UINT_ONE << i); }

    void set( int i, bool v )
 { v ? m_val |= (UINT_ONE << i) : m_val &= ~(UINT_ONE << i); }




    int length() const
 { return m_len; }
# 749 "../../../src/systemc/datatypes/int/sc_int_base.h"
    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return length(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const
 {
     if ( m_len < 64 )
  return (uint64)(m_val & ~((uint_type)-1 << m_len));
     else
  return (uint64)m_val;
 }
    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    bool and_reduce() const;

    bool nand_reduce() const
 { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
 { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
 { return ( ! xor_reduce() ); }




    operator int_type() const
 { return m_val; }




    int_type value() const
 { return operator int_type(); }


    int to_int() const
 { return (int) m_val; }

    unsigned int to_uint() const
 { return (unsigned int) m_val; }

    long to_long() const
 { return (long) m_val; }

    unsigned long to_ulong() const
 { return (unsigned long) m_val; }

    int64 to_int64() const
 { return (int64) m_val; }

    uint64 to_uint64() const
 { return (uint64) m_val; }

    double to_double() const
 { return (double) m_val; }



    long long_low() const
 { return (long) (m_val & UINT64_32ONES); }

    long long_high() const
 { return (long) ((m_val >> 32) & UINT64_32ONES); }





    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

    void scan( istream& is = cin );

protected:

    int_type m_val;
    int m_len;
    int m_ulen;
};



inline
ostream&
operator << ( ostream&, const sc_int_base& );

inline
istream&
operator >> ( istream&, sc_int_base& );
# 867 "../../../src/systemc/datatypes/int/sc_int_base.h"
inline
sc_int_bitref_r::operator bool () const
{
    return m_obj_p->test( m_index );
}

inline
bool
sc_int_bitref_r::operator ! () const
{
    return ! m_obj_p->test( m_index );
}

inline
bool
sc_int_bitref_r::operator ~ () const
{
    return ! m_obj_p->test( m_index );
}



inline
ostream&
operator << ( ostream& os, const sc_int_bitref_r& a )
{
    a.print( os );
    return os;
}
# 906 "../../../src/systemc/datatypes/int/sc_int_base.h"
inline
sc_int_bitref&
sc_int_bitref::operator = ( const sc_int_bitref_r& b )
{
    m_obj_p->set( m_index, (bool) b );
    m_obj_p->extend_sign();
    return *this;
}

inline
sc_int_bitref&
sc_int_bitref::operator = ( const sc_int_bitref& b )
{
    m_obj_p->set( m_index, (bool) b );
    m_obj_p->extend_sign();
    return *this;
}

inline
sc_int_bitref&
sc_int_bitref::operator = ( bool b )
{
    m_obj_p->set( m_index, b );
    m_obj_p->extend_sign();
    return *this;
}


inline
sc_int_bitref&
sc_int_bitref::operator &= ( bool b )
{
    if( ! b ) {
 m_obj_p->set( m_index, b );
 m_obj_p->extend_sign();
    }
    return *this;
}

inline
sc_int_bitref&
sc_int_bitref::operator |= ( bool b )
{
    if( b ) {
 m_obj_p->set( m_index, b );
 m_obj_p->extend_sign();
    }
    return *this;
}

inline
sc_int_bitref&
sc_int_bitref::operator ^= ( bool b )
{
    if( b ) {
 m_obj_p->m_val ^= (UINT_ONE << m_index);
 m_obj_p->extend_sign();
    }
    return *this;
}



inline
istream&
operator >> ( istream& is, sc_int_bitref& a )
{
    a.scan( is );
    return is;
}
# 986 "../../../src/systemc/datatypes/int/sc_int_base.h"
inline
sc_int_subref_r::operator uint_type() const
{
    int_type val = m_obj_p->m_val;
    int uleft = 64 - (m_left + 1);
    int uright = uleft + m_right;
    return ( val << uleft >> uright );
}




inline
bool
sc_int_subref_r::and_reduce() const
{
    sc_int_base a( *this );
    return a.and_reduce();
}

inline
bool
sc_int_subref_r::or_reduce() const
{
    sc_int_base a( *this );
    return a.or_reduce();
}

inline
bool
sc_int_subref_r::xor_reduce() const
{
    sc_int_base a( *this );
    return a.xor_reduce();
}




inline
int
sc_int_subref_r::to_int() const
{
    sc_int_base a( *this );
    return a.to_int();
}

inline
unsigned int
sc_int_subref_r::to_uint() const
{
    sc_int_base a( *this );
    return a.to_uint();
}

inline
long
sc_int_subref_r::to_long() const
{
    sc_int_base a( *this );
    return a.to_long();
}

inline
unsigned long
sc_int_subref_r::to_ulong() const
{
    sc_int_base a( *this );
    return a.to_ulong();
}

inline
int64
sc_int_subref_r::to_int64() const
{
    sc_int_base a( *this );
    return a.to_int64();
}

inline
uint64
sc_int_subref_r::to_uint64() const
{
    sc_int_base a( *this );
    return a.to_uint64();
}

inline
double
sc_int_subref_r::to_double() const
{
    sc_int_base a( *this );
    return a.to_double();
}




inline
const sc_string
sc_int_subref_r::to_string( sc_numrep numrep ) const
{
    sc_int_base a( *this );
    return a.to_string( numrep );
}

inline
const sc_string
sc_int_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
{
    sc_int_base a( *this );
    return a.to_string( numrep, w_prefix );
}




inline
bool
and_reduce( const sc_int_subref_r& a )
{
    return a.and_reduce();
}

inline
bool
nand_reduce( const sc_int_subref_r& a )
{
    return a.nand_reduce();
}

inline
bool
or_reduce( const sc_int_subref_r& a )
{
    return a.or_reduce();
}

inline
bool
nor_reduce( const sc_int_subref_r& a )
{
    return a.nor_reduce();
}

inline
bool
xor_reduce( const sc_int_subref_r& a )
{
    return a.xor_reduce();
}

inline
bool
xnor_reduce( const sc_int_subref_r& a )
{
    return a.xnor_reduce();
}



inline
ostream&
operator << ( ostream& os, const sc_int_subref_r& a )
{
    a.print( os );
    return os;
}
# 1164 "../../../src/systemc/datatypes/int/sc_int_base.h"
inline
sc_int_subref&
sc_int_subref::operator = ( const sc_int_base& a )
{
    return operator = ( a.operator int_type() );
}

inline
sc_int_subref&
sc_int_subref::operator = ( const char* a )
{
    sc_int_base aa( length() );
    return ( *this = aa = a );
}



inline
istream&
operator >> ( istream& is, sc_int_subref& a )
{
    a.scan( is );
    return is;
}
# 1198 "../../../src/systemc/datatypes/int/sc_int_base.h"
inline
sc_int_bitref
sc_int_base::operator [] ( int i )
{
    check_index( i );
    return sc_int_bitref( *this, i );
}

inline
sc_int_bitref_r
sc_int_base::operator [] ( int i ) const
{
    check_index( i );
    return sc_int_bitref_r( *this, i );
}


inline
sc_int_bitref
sc_int_base::bit( int i )
{
    check_index( i );
    return sc_int_bitref( *this, i );
}

inline
sc_int_bitref_r
sc_int_base::bit( int i ) const
{
    check_index( i );
    return sc_int_bitref_r( *this, i );
}




inline
sc_int_subref
sc_int_base::operator () ( int left, int right )
{
    check_range( left, right );
    return sc_int_subref( *this, left, right );
}

inline
sc_int_subref_r
sc_int_base::operator () ( int left, int right ) const
{
    check_range( left, right );
    return sc_int_subref_r( *this, left, right );
}


inline
sc_int_subref
sc_int_base::range( int left, int right )
{
    check_range( left, right );
    return sc_int_subref( *this, left, right );
}

inline
sc_int_subref_r
sc_int_base::range( int left, int right ) const
{
    check_range( left, right );
    return sc_int_subref_r( *this, left, right );
}




inline
bool
and_reduce( const sc_int_base& a )
{
    return a.and_reduce();
}

inline
bool
nand_reduce( const sc_int_base& a )
{
    return a.nand_reduce();
}

inline
bool
or_reduce( const sc_int_base& a )
{
    return a.or_reduce();
}

inline
bool
nor_reduce( const sc_int_base& a )
{
    return a.nor_reduce();
}

inline
bool
xor_reduce( const sc_int_base& a )
{
    return a.xor_reduce();
}

inline
bool
xnor_reduce( const sc_int_base& a )
{
    return a.xnor_reduce();
}



inline
ostream&
operator << ( ostream& os, const sc_int_base& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_int_base& a )
{
    a.scan( is );
    return is;
}

}
# 53 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_uint_base.h" 1
# 60 "../../../src/systemc/datatypes/int/sc_uint_base.h"
# 1 "../../../src/systemc/datatypes/fx/scfx_ieee.h" 1
# 61 "../../../src/systemc/datatypes/int/sc_uint_base.h" 2



namespace sc_dt
{

class sc_concatref;


class sc_uint_bitref_r;
class sc_uint_bitref;
class sc_uint_subref_r;
class sc_uint_subref;
class sc_uint_base;


class sc_bv_base;
class sc_lv_base;
class sc_signed;
class sc_unsigned;
class sc_fxval;
class sc_fxval_fast;
class sc_fxnum;
class sc_fxnum_fast;


extern const uint_type mask_int[64][64];
# 97 "../../../src/systemc/datatypes/int/sc_uint_base.h"
class sc_uint_bitref_r : public sc_value_base
{
    friend class sc_uint_base;
    friend class sc_uint_signal;

protected:



    sc_uint_bitref_r( const sc_uint_base& obj_, int index_ )
        : m_obj_p( const_cast<sc_uint_base*>( &obj_ ) ), m_index( index_ )
        {}
    sc_uint_bitref_r()
 {}

public:



    sc_uint_bitref_r( const sc_uint_bitref_r& a )
        : m_obj_p( a.m_obj_p ), m_index( a.m_index )
        {}



    virtual ~sc_uint_bitref_r()
 {}



    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return 1; }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const
        {
            int bit_mask = 1 << (low_i % 30);
            int word_i = low_i / 30;

     dst_p[word_i] &= ~bit_mask;
     return false;
        }
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const
        {
            int bit_mask = 1 << (low_i % 30);
     bool result;
            int word_i = low_i / 30;

            if ( operator uint64() )
     {
                dst_p[word_i] |= bit_mask;
  result = true;
     }
            else
     {
                dst_p[word_i] &= ~bit_mask;
  result = false;
     }
     return result;
        }
    virtual uint64 concat_get_uint64() const
 { return operator uint64(); }




    sc_uint_bitref_r* clone() const
        { return new sc_uint_bitref_r( *this ); }




    int length() const
 { return 1; }
# 179 "../../../src/systemc/datatypes/int/sc_uint_base.h"
    operator uint64 () const;
    bool operator ! () const;
    bool operator ~ () const;




    bool value() const
 { return operator uint64 (); }

    bool to_bool() const
 { return operator uint64 (); }




    void print( ostream& os = cout ) const
 { os << to_bool(); }

protected:

    sc_uint_base* m_obj_p;
    int m_index;

private:


    sc_uint_bitref_r& operator = ( const sc_uint_bitref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_uint_bitref_r& );
# 222 "../../../src/systemc/datatypes/int/sc_uint_base.h"
class sc_uint_bitref
    : public sc_uint_bitref_r
{
    friend class sc_uint_base;




    sc_uint_bitref( sc_uint_base& obj_, int index_ )
 : sc_uint_bitref_r( obj_, index_ )
 {}

public:



    sc_uint_bitref( const sc_uint_bitref& a )
 : sc_uint_bitref_r( a )
        {}




    sc_uint_bitref* clone() const
        { return new sc_uint_bitref( *this ); }




    sc_uint_bitref& operator = ( const sc_uint_bitref_r& b );
    sc_uint_bitref& operator = ( const sc_uint_bitref& b );
    sc_uint_bitref& operator = ( bool b );

    sc_uint_bitref& operator &= ( bool b );
    sc_uint_bitref& operator |= ( bool b );
    sc_uint_bitref& operator ^= ( bool b );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    void scan( istream& is = cin );

private:


    sc_uint_bitref();
};



inline
istream&
operator >> ( istream&, sc_uint_bitref& );
# 289 "../../../src/systemc/datatypes/int/sc_uint_base.h"
class sc_uint_subref_r : public sc_value_base
{
    friend class sc_uint_base;

protected:



    sc_uint_subref_r( const sc_uint_base& obj_, int left_, int right_ )
        : m_obj_p( const_cast<sc_uint_base*>( &obj_ ) ),
   m_left( left_ ), m_right( right_ )
        {}
    sc_uint_subref_r() : m_obj_p(0)
 {}

public:



    sc_uint_subref_r( const sc_uint_subref_r& a )
        : m_obj_p( a.m_obj_p ), m_left( a.m_left ), m_right( a.m_right )
        {}



    virtual ~sc_uint_subref_r()
 {}



    sc_uint_subref_r* clone() const
        { return new sc_uint_subref_r( *this ); }




    int length() const
 { return ( m_left - m_right + 1 ); }
# 335 "../../../src/systemc/datatypes/int/sc_uint_base.h"
    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return length(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const
 { return (uint64)operator uint_type(); }




    bool and_reduce() const;

    bool nand_reduce() const
 { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
 { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
 { return ( ! xor_reduce() ); }




    operator uint_type() const;




    uint_type value() const
 { return operator uint_type(); }


    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    int64 to_int64() const;
    uint64 to_uint64() const;
    double to_double() const;




    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

protected:

    sc_uint_base* m_obj_p;
    int m_left;
    int m_right;

private:


    sc_uint_subref_r& operator = ( const sc_uint_subref_r& );
};



inline
ostream&
operator << ( ostream&, const sc_uint_subref_r& );
# 417 "../../../src/systemc/datatypes/int/sc_uint_base.h"
class sc_uint_subref
    : public sc_uint_subref_r
{
    friend class sc_uint_base;




    sc_uint_subref( sc_uint_base& obj_, int left_, int right_ )
 : sc_uint_subref_r( obj_, left_, right_ )
        {}

public:



    sc_uint_subref( const sc_uint_subref& a )
 : sc_uint_subref_r( a )
        {}




    sc_uint_subref* clone() const
        { return new sc_uint_subref( *this ); }




    sc_uint_subref& operator = ( uint_type v );

    sc_uint_subref& operator = ( const sc_uint_base& a );

    sc_uint_subref& operator = ( const sc_uint_subref_r& a )
 { return operator = ( a.operator uint_type() ); }

    sc_uint_subref& operator = ( const sc_uint_subref& a )
 { return operator = ( a.operator uint_type() ); }

    sc_uint_subref& operator = ( const sc_concatref& a );


    sc_uint_subref& operator = ( const char* a );

    sc_uint_subref& operator = ( unsigned long a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( long a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( unsigned int a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( int a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( int64 a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( double a )
 { return operator = ( (uint_type) a ); }

    sc_uint_subref& operator = ( const sc_signed& );
    sc_uint_subref& operator = ( const sc_unsigned& );
    sc_uint_subref& operator = ( const sc_bv_base& );
    sc_uint_subref& operator = ( const sc_lv_base& );



    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);



    void scan( istream& is = cin );

private:


    sc_uint_subref();
};



inline
istream&
operator >> ( istream&, sc_uint_subref& );
# 514 "../../../src/systemc/datatypes/int/sc_uint_base.h"
class sc_uint_base : public sc_value_base
{
    friend class sc_uint_bitref_r;
    friend class sc_uint_bitref;
    friend class sc_uint_subref_r;
    friend class sc_uint_subref;




    void invalid_length() const;
    void invalid_index( int i ) const;
    void invalid_range( int l, int r ) const;

    void check_length() const
 { if( m_len <= 0 || m_len > 64 ) { invalid_length(); } }

    void check_index( int i ) const
 { if( i < 0 || i >= m_len ) { invalid_index( i ); } }

    void check_range( int l, int r ) const
 { if( r < 0 || l >= m_len || l < r ) { invalid_range( l, r ); } }

    void check_value() const;

    void extend_sign()
 {



     m_val &= ( ~UINT_ZERO >> m_ulen );
 }

public:



    explicit sc_uint_base( int w = sc_length_param().len() )
 : m_val( 0 ), m_len( w ), m_ulen( 64 - m_len )
 { check_length(); }

    sc_uint_base( uint_type v, int w )
 : m_val( v ), m_len( w ), m_ulen( 64 - m_len )
 { check_length(); extend_sign(); }

    sc_uint_base( const sc_uint_base& a )
 : m_val( a.m_val ), m_len( a.m_len ), m_ulen( a.m_ulen )
 {}

    explicit sc_uint_base( const sc_uint_subref_r& a )
        : m_val( a ), m_len( a.length() ), m_ulen( 64 - m_len )
        { extend_sign(); }

    explicit sc_uint_base( const sc_concatref& a );





    explicit sc_uint_base( const sc_signed& a );
    explicit sc_uint_base( const sc_unsigned& a );




    virtual ~sc_uint_base()
 {}




    sc_uint_base& operator = ( uint_type v )
 { m_val = v; extend_sign(); return *this; }

    sc_uint_base& operator = ( const sc_uint_base& a )
 { m_val = a.m_val; extend_sign(); return *this; }

    sc_uint_base& operator = ( const sc_uint_subref_r& a )
        { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( const sc_concatref& a );


    sc_uint_base& operator = ( const sc_signed& a );
    sc_uint_base& operator = ( const sc_unsigned& a );


    sc_uint_base& operator = ( const sc_fxval& a );
    sc_uint_base& operator = ( const sc_fxval_fast& a );
    sc_uint_base& operator = ( const sc_fxnum& a );
    sc_uint_base& operator = ( const sc_fxnum_fast& a );


    sc_uint_base& operator = ( const sc_bv_base& a );
    sc_uint_base& operator = ( const sc_lv_base& a );

    sc_uint_base& operator = ( const char* a );

    sc_uint_base& operator = ( unsigned long a )
 { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( long a )
 { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( unsigned int a )
 { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( int a )
 { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( int64 a )
 { m_val = a; extend_sign(); return *this; }

    sc_uint_base& operator = ( double a )
 { m_val = (uint_type) a; extend_sign(); return *this; }




    sc_uint_base& operator += ( uint_type v )
 { m_val += v; extend_sign(); return *this; }

    sc_uint_base& operator -= ( uint_type v )
 { m_val -= v; extend_sign(); return *this; }

    sc_uint_base& operator *= ( uint_type v )
 { m_val *= v; extend_sign(); return *this; }

    sc_uint_base& operator /= ( uint_type v )
 { m_val /= v; extend_sign(); return *this; }

    sc_uint_base& operator %= ( uint_type v )
 { m_val %= v; extend_sign(); return *this; }




    sc_uint_base& operator &= ( uint_type v )
 { m_val &= v; extend_sign(); return *this; }

    sc_uint_base& operator |= ( uint_type v )
 { m_val |= v; extend_sign(); return *this; }

    sc_uint_base& operator ^= ( uint_type v )
 { m_val ^= v; extend_sign(); return *this; }


    sc_uint_base& operator <<= ( uint_type v )
 { m_val <<= v; extend_sign(); return *this; }

    sc_uint_base& operator >>= ( uint_type v )
 { m_val >>= v; return *this; }




    sc_uint_base& operator ++ ()
 { ++ m_val; extend_sign(); return *this; }

    const sc_uint_base operator ++ ( int )
 { sc_uint_base tmp( *this ); ++ m_val; extend_sign(); return tmp; }

    sc_uint_base& operator -- ()
 { -- m_val; extend_sign(); return *this; }

    const sc_uint_base operator -- ( int )
 { sc_uint_base tmp( *this ); -- m_val; extend_sign(); return tmp; }




    friend bool operator == ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val == b.m_val; }

    friend bool operator != ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val != b.m_val; }

    friend bool operator < ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val < b.m_val; }

    friend bool operator <= ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val <= b.m_val; }

    friend bool operator > ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val > b.m_val; }

    friend bool operator >= ( const sc_uint_base& a, const sc_uint_base& b )
 { return a.m_val >= b.m_val; }




    sc_uint_bitref operator [] ( int i );
    sc_uint_bitref_r operator [] ( int i ) const;

    sc_uint_bitref bit( int i );
    sc_uint_bitref_r bit( int i ) const;




    sc_uint_subref operator () ( int left, int right );
    sc_uint_subref_r operator () ( int left, int right ) const;

    sc_uint_subref range( int left, int right );
    sc_uint_subref_r range( int left, int right ) const;




    bool test( int i ) const
 { return ( 0 != (m_val & (UINT_ONE << i)) ); }

    void set( int i )
 { m_val |= (UINT_ONE << i); }

    void set( int i, bool v )
 { v ? m_val |= (UINT_ONE << i) : m_val &= ~(UINT_ONE << i); }




    int length() const
 { return m_len; }
# 746 "../../../src/systemc/datatypes/int/sc_uint_base.h"
    virtual int concat_length(bool* xz_present_p) const
 { if ( xz_present_p ) *xz_present_p = false; return length(); }
    virtual bool concat_get_ctrl( unsigned long* dst_p, int low_i ) const;
    virtual bool concat_get_data( unsigned long* dst_p, int low_i ) const;
    virtual uint64 concat_get_uint64() const
        { return m_val; }
    virtual void concat_set(int64 src, int low_i);
    virtual void concat_set(const sc_signed& src, int low_i);
    virtual void concat_set(const sc_unsigned& src, int low_i);
    virtual void concat_set(uint64 src, int low_i);




    bool and_reduce() const;

    bool nand_reduce() const
 { return ( ! and_reduce() ); }

    bool or_reduce() const;

    bool nor_reduce() const
 { return ( ! or_reduce() ); }

    bool xor_reduce() const;

    bool xnor_reduce() const
 { return ( ! xor_reduce() ); }




    operator uint_type() const
 { return m_val; }




    uint_type value() const
 { return operator uint_type(); }


    int to_int() const
 { return (int) m_val; }

    unsigned int to_uint() const
 { return (unsigned int) m_val; }

    long to_long() const
 { return (long) m_val; }

    unsigned long to_ulong() const
 { return (unsigned long) m_val; }

    int64 to_int64() const
 { return (int64) m_val; }

    uint64 to_uint64() const
 { return (uint64) m_val; }

    double to_double() const
        { return uint64_to_double( m_val ); }



    long long_low() const
 { return (long) (m_val & UINT64_32ONES); }

    long long_high() const
 { return (long) ((m_val >> 32) & UINT64_32ONES); }




    const sc_string to_string( sc_numrep numrep = SC_DEC ) const;
    const sc_string to_string( sc_numrep numrep, bool w_prefix ) const;




    void print( ostream& os = cout ) const
 { os << to_string(); }

    void scan( istream& is = cin );

protected:

    uint_type m_val;
    int m_len;
    int m_ulen;
};



inline
ostream&
operator << ( ostream&, const sc_uint_base& );

inline
istream&
operator >> ( istream&, sc_uint_base& );
# 858 "../../../src/systemc/datatypes/int/sc_uint_base.h"
inline

sc_uint_bitref_r::operator uint64 () const
{
    return m_obj_p->test( m_index );
}

inline
bool
sc_uint_bitref_r::operator ! () const
{
    return ! m_obj_p->test( m_index );
}

inline
bool
sc_uint_bitref_r::operator ~ () const
{
    return ! m_obj_p->test( m_index );
}



inline
ostream&
operator << ( ostream& os, const sc_uint_bitref_r& a )
{
    a.print( os );
    return os;
}
# 898 "../../../src/systemc/datatypes/int/sc_uint_base.h"
inline
sc_uint_bitref&
sc_uint_bitref::operator = ( const sc_uint_bitref_r& b )
{
    m_obj_p->set( m_index, b.to_bool() );
    return *this;
}

inline
sc_uint_bitref&
sc_uint_bitref::operator = ( const sc_uint_bitref& b )
{
    m_obj_p->set( m_index, b.to_bool() );
    return *this;
}

inline
sc_uint_bitref&
sc_uint_bitref::operator = ( bool b )
{
    m_obj_p->set( m_index, b );
    return *this;
}


inline
sc_uint_bitref&
sc_uint_bitref::operator &= ( bool b )
{
    if( ! b ) {
 m_obj_p->set( m_index, b );
    }
    return *this;
}

inline
sc_uint_bitref&
sc_uint_bitref::operator |= ( bool b )
{
    if( b ) {
 m_obj_p->set( m_index, b );
    }
    return *this;
}

inline
sc_uint_bitref&
sc_uint_bitref::operator ^= ( bool b )
{
    if( b ) {
 m_obj_p->m_val ^= (UINT_ONE << m_index);
    }
    return *this;
}



inline
istream&
operator >> ( istream& is, sc_uint_bitref& a )
{
    a.scan( is );
    return is;
}
# 972 "../../../src/systemc/datatypes/int/sc_uint_base.h"
inline
sc_uint_subref_r::operator uint_type() const
{
    uint_type val = m_obj_p->m_val;
    int uleft = 64 - (m_left + 1);
    return ( (val & (~UINT_ZERO >> uleft)) >> m_right );
}




inline
bool
sc_uint_subref_r::and_reduce() const
{
    sc_uint_base a( *this );
    return a.and_reduce();
}

inline
bool
sc_uint_subref_r::or_reduce() const
{
    sc_uint_base a( *this );
    return a.or_reduce();
}

inline
bool
sc_uint_subref_r::xor_reduce() const
{
    sc_uint_base a( *this );
    return a.xor_reduce();
}




inline
int
sc_uint_subref_r::to_int() const
{
    sc_uint_base a( *this );
    return a.to_int();
}

inline
unsigned int
sc_uint_subref_r::to_uint() const
{
    sc_uint_base a( *this );
    return a.to_uint();
}

inline
long
sc_uint_subref_r::to_long() const
{
    sc_uint_base a( *this );
    return a.to_long();
}

inline
unsigned long
sc_uint_subref_r::to_ulong() const
{
    sc_uint_base a( *this );
    return a.to_ulong();
}

inline
int64
sc_uint_subref_r::to_int64() const
{
    sc_uint_base a( *this );
    return a.to_int64();
}

inline
uint64
sc_uint_subref_r::to_uint64() const
{
    sc_uint_base a( *this );
    return a.to_uint64();
}

inline
double
sc_uint_subref_r::to_double() const
{
    sc_uint_base a( *this );
    return a.to_double();
}




inline
const sc_string
sc_uint_subref_r::to_string( sc_numrep numrep ) const
{
    sc_uint_base a( *this );
    return a.to_string( numrep );
}

inline
const sc_string
sc_uint_subref_r::to_string( sc_numrep numrep, bool w_prefix ) const
{
    sc_uint_base a( *this );
    return a.to_string( numrep, w_prefix );
}




inline
bool
and_reduce( const sc_uint_subref_r& a )
{
    return a.and_reduce();
}

inline
bool
nand_reduce( const sc_uint_subref_r& a )
{
    return a.nand_reduce();
}

inline
bool
or_reduce( const sc_uint_subref_r& a )
{
    return a.or_reduce();
}

inline
bool
nor_reduce( const sc_uint_subref_r& a )
{
    return a.nor_reduce();
}

inline
bool
xor_reduce( const sc_uint_subref_r& a )
{
    return a.xor_reduce();
}

inline
bool
xnor_reduce( const sc_uint_subref_r& a )
{
    return a.xnor_reduce();
}



inline
ostream&
operator << ( ostream& os, const sc_uint_subref_r& a )
{
    a.print( os );
    return os;
}
# 1149 "../../../src/systemc/datatypes/int/sc_uint_base.h"
inline
sc_uint_subref&
sc_uint_subref::operator = ( const sc_uint_base& a )
{
    return operator = ( a.operator uint_type() );
}

inline
sc_uint_subref&
sc_uint_subref::operator = ( const char* a )
{
    sc_uint_base aa( length() );
    return ( *this = aa = a );
}



inline
istream&
operator >> ( istream& is, sc_uint_subref& a )
{
    a.scan( is );
    return is;
}
# 1183 "../../../src/systemc/datatypes/int/sc_uint_base.h"
inline
sc_uint_bitref
sc_uint_base::operator [] ( int i )
{
    check_index( i );
    return sc_uint_bitref( *this, i );
}

inline
sc_uint_bitref_r
sc_uint_base::operator [] ( int i ) const
{
    check_index( i );
    return sc_uint_bitref_r( *this, i );
}


inline
sc_uint_bitref
sc_uint_base::bit( int i )
{
    check_index( i );
    return sc_uint_bitref( *this, i );
}

inline
sc_uint_bitref_r
sc_uint_base::bit( int i ) const
{
    check_index( i );
    return sc_uint_bitref_r( *this, i );
}




inline
sc_uint_subref
sc_uint_base::operator () ( int left, int right )
{
    check_range( left, right );
    return sc_uint_subref( *this, left, right );
}

inline
sc_uint_subref_r
sc_uint_base::operator () ( int left, int right ) const
{
    check_range( left, right );
    return sc_uint_subref_r( *this, left, right );
}


inline
sc_uint_subref
sc_uint_base::range( int left, int right )
{
    check_range( left, right );
    return sc_uint_subref( *this, left, right );
}

inline
sc_uint_subref_r
sc_uint_base::range( int left, int right ) const
{
    check_range( left, right );
    return sc_uint_subref_r( *this, left, right );
}




inline
bool
and_reduce( const sc_uint_base& a )
{
    return a.and_reduce();
}

inline
bool
nand_reduce( const sc_uint_base& a )
{
    return a.nand_reduce();
}

inline
bool
or_reduce( const sc_uint_base& a )
{
    return a.or_reduce();
}

inline
bool
nor_reduce( const sc_uint_base& a )
{
    return a.nor_reduce();
}

inline
bool
xor_reduce( const sc_uint_base& a )
{
    return a.xor_reduce();
}

inline
bool
xnor_reduce( const sc_uint_base& a )
{
    return a.xnor_reduce();
}



inline
ostream&
operator << ( ostream& os, const sc_uint_base& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_uint_base& a )
{
    a.scan( is );
    return is;
}

}
# 54 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2
# 1 "../../../src/systemc/utils/sc_string.h" 1
# 55 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2


# 1 "../../../src/systemc/datatypes/bit/sc_logic.h" 1
# 58 "../../../src/systemc/datatypes/bit/sc_proxy.h" 2



namespace sc_dt
{


template <class X> class sc_proxy;


class sc_bv_base;
class sc_lv_base;
template <class X> class sc_bitref_r;
template <class X> class sc_bitref;
template <class X> class sc_subref_r;
template <class X> class sc_subref;
template <class X, class Y> class sc_concref_r;
template <class X, class Y> class sc_concref;


const int UL_SIZE = 8 * sizeof( unsigned long );

const unsigned long UL_ZERO = 0ul;
const unsigned long UL_ONE = 1ul;
const unsigned long UL_TWO = 2ul;




template <class X, class Y>
inline
void
assign_p_( sc_proxy<X>& px, const sc_proxy<Y>& py );






template <class X, class T>
inline
void
assign_v_( sc_proxy<X>& px, const T& a );




const sc_string convert_to_bin( const char* s );
const sc_string convert_to_fmt( const sc_string& s, sc_numrep numrep, bool );
# 116 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X>
class sc_proxy
{
public:



    virtual ~sc_proxy() {}




    X& back_cast()
 { return static_cast<X&>( *this ); }

    const X& back_cast() const
 { return static_cast<const X&>( *this ); }




    template <class Y>
    X& assign_( const sc_proxy<Y>& a )
 { assign_p_( *this, a ); return back_cast(); }

    X& assign_( const char* a );
    X& assign_( const bool* a );
    X& assign_( const sc_logic* a );

    X& assign_( const sc_unsigned& a )
 { assign_v_( *this, a ); return back_cast(); }

    X& assign_( const sc_signed& a )
 { assign_v_( *this, a ); return back_cast(); }

    X& assign_( const sc_uint_base& a )
 { return assign_( (uint64) a ); }

    X& assign_( const sc_int_base& a )
 { return assign_( (int64) a ); }

    X& assign_( unsigned long a );
    X& assign_( long a );

    X& assign_( unsigned int a )
 { return assign_( (unsigned long) a ); }

    X& assign_( int a )
 { return assign_( (long) a ); }

    X& assign_( uint64 a );
    X& assign_( int64 a );






    X& b_not();

    const sc_lv_base operator ~ () const;




    X& operator &= ( const char* b );
    X& operator &= ( const bool* b );
    X& operator &= ( const sc_logic* b );
    X& operator &= ( const sc_unsigned& b );
    X& operator &= ( const sc_signed& b );

    X& operator &= ( const sc_uint_base& b )
 { return operator &= ( (uint64) b ); }

    X& operator &= ( const sc_int_base& b )
 { return operator &= ( (int64) b ); }

    X& operator &= ( unsigned long b );
    X& operator &= ( long b );

    X& operator &= ( unsigned int b )
 { return operator &= ( (unsigned long) b ); }

    X& operator &= ( int b )
 { return operator &= ( (long) b ); }

    X& operator &= ( uint64 b );
    X& operator &= ( int64 b );


    const sc_lv_base operator & ( const char* b ) const;
    const sc_lv_base operator & ( const bool* b ) const;
    const sc_lv_base operator & ( const sc_logic* b ) const;
    const sc_lv_base operator & ( const sc_unsigned& b ) const;
    const sc_lv_base operator & ( const sc_signed& b ) const;
    const sc_lv_base operator & ( const sc_uint_base& b ) const;
    const sc_lv_base operator & ( const sc_int_base& b ) const;
    const sc_lv_base operator & ( unsigned long b ) const;
    const sc_lv_base operator & ( long b ) const;
    const sc_lv_base operator & ( unsigned int b ) const;
    const sc_lv_base operator & ( int b ) const;
    const sc_lv_base operator & ( uint64 b ) const;
    const sc_lv_base operator & ( int64 b ) const;




    X& operator |= ( const char* b );
    X& operator |= ( const bool* b );
    X& operator |= ( const sc_logic* b );
    X& operator |= ( const sc_unsigned& b );
    X& operator |= ( const sc_signed& b );

    X& operator |= ( const sc_uint_base& b )
 { return operator |= ( (uint64) b ); }

    X& operator |= ( const sc_int_base& b )
 { return operator |= ( (int64) b ); }

    X& operator |= ( unsigned long b );
    X& operator |= ( long b );

    X& operator |= ( unsigned int b )
 { return operator |= ( (unsigned long) b ); }

    X& operator |= ( int b )
 { return operator |= ( (long) b ); }

    X& operator |= ( uint64 b );
    X& operator |= ( int64 b );


    const sc_lv_base operator | ( const char* b ) const;
    const sc_lv_base operator | ( const bool* b ) const;
    const sc_lv_base operator | ( const sc_logic* b ) const;
    const sc_lv_base operator | ( const sc_unsigned& b ) const;
    const sc_lv_base operator | ( const sc_signed& b ) const;
    const sc_lv_base operator | ( const sc_uint_base& b ) const;
    const sc_lv_base operator | ( const sc_int_base& b ) const;
    const sc_lv_base operator | ( unsigned long b ) const;
    const sc_lv_base operator | ( long b ) const;
    const sc_lv_base operator | ( unsigned int b ) const;
    const sc_lv_base operator | ( int b ) const;
    const sc_lv_base operator | ( uint64 b ) const;
    const sc_lv_base operator | ( int64 b ) const;




    X& operator ^= ( const char* b );
    X& operator ^= ( const bool* b );
    X& operator ^= ( const sc_logic* b );
    X& operator ^= ( const sc_unsigned& b );
    X& operator ^= ( const sc_signed& b );

    X& operator ^= ( const sc_uint_base& b )
 { return operator ^= ( (uint64) b ); }

    X& operator ^= ( const sc_int_base& b )
 { return operator ^= ( (int64) b ); }

    X& operator ^= ( unsigned long b );
    X& operator ^= ( long b );

    X& operator ^= ( unsigned int b )
 { return operator ^= ( (unsigned long) b ); }

    X& operator ^= ( int b )
 { return operator ^= ( (long) b ); }

    X& operator ^= ( uint64 b );
    X& operator ^= ( int64 b );


    const sc_lv_base operator ^ ( const char* b ) const;
    const sc_lv_base operator ^ ( const bool* b ) const;
    const sc_lv_base operator ^ ( const sc_logic* b ) const;
    const sc_lv_base operator ^ ( const sc_unsigned& b ) const;
    const sc_lv_base operator ^ ( const sc_signed& b ) const;
    const sc_lv_base operator ^ ( const sc_uint_base& b ) const;
    const sc_lv_base operator ^ ( const sc_int_base& b ) const;
    const sc_lv_base operator ^ ( unsigned long b ) const;
    const sc_lv_base operator ^ ( long b ) const;
    const sc_lv_base operator ^ ( unsigned int b ) const;
    const sc_lv_base operator ^ ( int b ) const;
    const sc_lv_base operator ^ ( uint64 b ) const;
    const sc_lv_base operator ^ ( int64 b ) const;




    X& operator <<= ( int n );

    const sc_lv_base operator << ( int n ) const;




    X& operator >>= ( int n );

    const sc_lv_base operator >> ( int n ) const;




    X& lrotate( int n );




    X& rrotate( int n );




    X& reverse();




    sc_bitref<X> operator [] ( int i )
 { return sc_bitref<X>( back_cast(), i ); }

    sc_bitref_r<X> operator [] ( int i ) const
 { return sc_bitref_r<X>( back_cast(), i ); }

    sc_bitref<X> bit( int i )
 { return sc_bitref<X>( back_cast(), i ); }

    sc_bitref_r<X> bit( int i ) const
 { return sc_bitref_r<X>( back_cast(), i ); }




    sc_subref<X> operator () ( int hi, int lo )
 { return sc_subref<X>( back_cast(), hi, lo ); }

    sc_subref_r<X> operator () ( int hi, int lo ) const
 { return sc_subref_r<X>( back_cast(), hi, lo ); }

    sc_subref<X> range( int hi, int lo )
 { return sc_subref<X>( back_cast(), hi, lo ); }

    sc_subref_r<X> range( int hi, int lo ) const
 { return sc_subref_r<X>( back_cast(), hi, lo ); }




    sc_logic_value_t and_reduce() const;

    sc_logic_value_t nand_reduce() const
 { return sc_logic::not_table[and_reduce()]; }

    sc_logic_value_t or_reduce() const;

    sc_logic_value_t nor_reduce() const
 { return sc_logic::not_table[or_reduce()]; }

    sc_logic_value_t xor_reduce() const;

    sc_logic_value_t xnor_reduce() const
 { return sc_logic::not_table[xor_reduce()]; }




    bool operator == ( const char* b ) const;
    bool operator == ( const bool* b ) const;
    bool operator == ( const sc_logic* b ) const;
    bool operator == ( const sc_unsigned& b ) const;
    bool operator == ( const sc_signed& b ) const;
    bool operator == ( const sc_uint_base& b ) const;
    bool operator == ( const sc_int_base& b ) const;
    bool operator == ( unsigned long b ) const;
    bool operator == ( long b ) const;
    bool operator == ( unsigned int b ) const;
    bool operator == ( int b ) const;
    bool operator == ( uint64 b ) const;
    bool operator == ( int64 b ) const;




    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;




    inline uint64 to_uint64() const;
    int to_int() const
 { return to_anything_signed(); }

    unsigned int to_uint() const
 { return to_anything_unsigned(); }

    long to_long() const
 { return to_anything_signed(); }

    unsigned long to_ulong() const
 { return to_anything_unsigned(); }
# 434 "../../../src/systemc/datatypes/bit/sc_proxy.h"
    void print( ostream& os = cout ) const
 { os << to_string(); }

    void scan( istream& is = cin );

protected:

    void check_bounds( int n ) const;
    void check_wbounds( int n ) const;

    unsigned long to_anything_unsigned() const;
    long to_anything_signed() const;
};
# 455 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X, class Y>
inline
X&
operator &= ( sc_proxy<X>& px, const sc_proxy<Y>& py );


template <class X, class Y>
inline
const sc_lv_base
operator & ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
# 473 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X> inline const sc_lv_base operator & ( const char* b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const bool* b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const sc_logic* b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const sc_unsigned& b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const sc_signed& b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const sc_uint_base& b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( const sc_int_base& b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( unsigned long b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( long b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( unsigned int b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( int b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( uint64 b, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator & ( int64 b, const sc_proxy<X>& px );






template <class X, class Y>
inline
X&
operator |= ( sc_proxy<X>& px, const sc_proxy<Y>& py );


template <class X, class Y>
inline
const sc_lv_base
operator | ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
# 510 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X> inline const sc_lv_base operator | ( const char* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const bool* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const sc_logic* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const sc_unsigned& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const sc_signed& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const sc_uint_base& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( const sc_int_base& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( unsigned long a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( long a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( unsigned int a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( int a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( uint64 a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator | ( int64 a, const sc_proxy<X>& px );






template <class X, class Y>
inline
X&
operator ^= ( sc_proxy<X>& px, const sc_proxy<Y>& py );


template <class X, class Y>
inline
const sc_lv_base
operator ^ ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
# 547 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X> inline const sc_lv_base operator ^ ( const char* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const bool* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const sc_logic* a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const sc_unsigned& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const sc_signed& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const sc_uint_base& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( const sc_int_base& a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( unsigned long a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( long a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( unsigned int a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( int a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( uint64 a, const sc_proxy<X>& px );
template <class X> inline const sc_lv_base operator ^ ( int64 a, const sc_proxy<X>& px );






template <class X, class Y>
inline
bool
operator == ( const sc_proxy<X>& px, const sc_proxy<Y>& py );

template <class X, class Y>
inline
bool
operator != ( const sc_proxy<X>& px, const sc_proxy<Y>& py );
# 593 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X> inline bool operator == ( const char* b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const char* b ); template <class X> inline bool operator != ( const char* b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const bool* b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const bool* b ); template <class X> inline bool operator != ( const bool* b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const sc_logic* b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_logic* b ); template <class X> inline bool operator != ( const sc_logic* b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const sc_unsigned& b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_unsigned& b ); template <class X> inline bool operator != ( const sc_unsigned& b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const sc_signed& b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_signed& b ); template <class X> inline bool operator != ( const sc_signed& b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const sc_uint_base& b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_uint_base& b ); template <class X> inline bool operator != ( const sc_uint_base& b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( const sc_int_base& b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_int_base& b ); template <class X> inline bool operator != ( const sc_int_base& b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( unsigned long b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, unsigned long b ); template <class X> inline bool operator != ( unsigned long b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( long b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, long b ); template <class X> inline bool operator != ( long b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( unsigned int b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, unsigned int b ); template <class X> inline bool operator != ( unsigned int b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( int b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, int b ); template <class X> inline bool operator != ( int b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( uint64 b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, uint64 b ); template <class X> inline bool operator != ( uint64 b, const sc_proxy<X>& px );
template <class X> inline bool operator == ( int64 b, const sc_proxy<X>& px ); template <class X> inline bool operator != ( const sc_proxy<X>& px, int64 b ); template <class X> inline bool operator != ( int64 b, const sc_proxy<X>& px );
# 619 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X>
inline
void
get_words_( const X& x, int wi, unsigned long& x_dw, unsigned long& x_cw )
{
    x_dw = x.get_word( wi );
    x_cw = x.get_cword( wi );
}

template <class X>
inline
void
set_words_( X& x, int wi, unsigned long x_dw, unsigned long x_cw )
{
    x.set_word( wi, x_dw );
    x.set_cword( wi, x_cw );
}

template <class X>
inline
void
extend_sign_w_( X& x, int wi, bool sign )
{
    int sz = x.size();
    unsigned long sgn = (sign ? ~UL_ZERO : UL_ZERO);
    for( int i = wi; i < sz; ++ i ) {
 set_words_( x, i, sgn, UL_ZERO );
    }
}




template <class X, class Y>
inline
void
assign_p_( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    if( (void*) &px != (void*) &py ) {
 X& x = px.back_cast();
 const Y& y = py.back_cast();
 int sz = x.size();
 int min_sz = sc_min( sz, y.size() );
 int i = 0;
 for( ; i < min_sz; ++ i ) {
     set_words_( x, i, y.get_word( i ), y.get_cword( i ) );
 }

 extend_sign_w_( x, i, false );
 x.clean_tail();
    }
}






template <class X, class T>
inline
void
assign_v_( sc_proxy<X>& px, const T& a )
{
    X& x = px.back_cast();
    int len = x.length();
    for( int i = 0 ; i < len; ++ i ) {
        x.set_bit( i, sc_logic_value_t( (bool) a[i] ) );
    }
}




template <class X>
inline
X&
sc_proxy<X>::assign_( const char* a )
{
    X& x = back_cast();
    sc_string s = convert_to_bin( a );
    int len = x.length();
    int s_len = s.length() - 1;
    int min_len = sc_min( len, s_len );
    int i = 0;
    for( ; i < min_len; ++ i ) {
 char c = s[s_len - i - 1];
 x.set_bit( i, sc_logic::char_to_logic[c] );
    }

    sc_logic_value_t fill = (s[s_len] == 'F' ? sc_logic_value_t( s[0] - '0' )
                               : sc_logic_value_t( 0 ));
    for( ; i < len; ++ i ) {
 x.set_bit( i, fill );
    }
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( const bool* a )
{

    X& x = back_cast();
    int len = x.length();
    for( int i = 0; i < len; ++ i ) {
 x.set_bit( i, sc_logic_value_t( a[i] ) );
    }
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( const sc_logic* a )
{

    X& x = back_cast();
    int len = x.length();
    for( int i = 0; i < len; ++ i ) {
 x.set_bit( i, a[i].value() );
    }
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( unsigned long a )
{
    X& x = back_cast();
    set_words_( x, 0, a, UL_ZERO );

    extend_sign_w_( x, 1, false );
    x.clean_tail();
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( long a )
{
    X& x = back_cast();
    set_words_( x, 0, (unsigned long) a, UL_ZERO );

    extend_sign_w_( x, 1, (a < 0) );
    x.clean_tail();
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( uint64 a )
{
    X& x = back_cast();
    set_words_( x, 0, ((unsigned long) a & ~UL_ZERO), UL_ZERO );
    if( x.size() > 1 ) {
 set_words_( x, 1,
      ((unsigned long) (a >> UL_SIZE) & ~UL_ZERO),
      UL_ZERO );

 extend_sign_w_( x, 2, false );
    }
    x.clean_tail();
    return x;
}

template <class X>
inline
X&
sc_proxy<X>::assign_( int64 a )
{
    X& x = back_cast();
    set_words_( x, 0, ((unsigned long) a & ~UL_ZERO), UL_ZERO );
    if( x.size() > 1 ) {
 set_words_( x, 1,
      ((unsigned long) ((uint64) a >> UL_SIZE) & ~UL_ZERO),
      UL_ZERO );

 extend_sign_w_( x, 2, (a < 0) );
    }
    x.clean_tail();
    return x;
}






template <class X>
inline
X&
sc_proxy<X>::b_not()
{
    X& x = back_cast();
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 unsigned long x_dw, x_cw;
 get_words_( x, i, x_dw, x_cw );
 x.set_word( i, x_cw | ~x_dw );
    }
    x.clean_tail();
    return x;
}




template <class X, class Y>
inline
X&
b_and_assign_( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    X& x = px.back_cast();
    const Y& y = py.back_cast();
    (static_cast<void> ((x.length() == y.length()) ? 0 : (__assert_fail ("x.length() == y.length()", "../../../src/systemc/datatypes/bit/sc_proxy.h", 837, __PRETTY_FUNCTION__), 0)));
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 unsigned long x_dw, x_cw, y_dw, y_cw;
 get_words_( x, i, x_dw, x_cw );
 get_words_( y, i, y_dw, y_cw );
 unsigned long cw = x_dw & y_cw | x_cw & y_dw | x_cw & y_cw;
 unsigned long dw = cw | x_dw & y_dw;
 set_words_( x, i, dw, cw );
    }

    return x;
}




template <class X, class Y>
inline
X&
b_or_assign_( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    X& x = px.back_cast();
    const Y& y = py.back_cast();
    (static_cast<void> ((x.length() == y.length()) ? 0 : (__assert_fail ("x.length() == y.length()", "../../../src/systemc/datatypes/bit/sc_proxy.h", 861, __PRETTY_FUNCTION__), 0)));
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 unsigned long x_dw, x_cw, y_dw, y_cw;
 get_words_( x, i, x_dw, x_cw );
 get_words_( y, i, y_dw, y_cw );
 unsigned long cw = x_cw & y_cw | x_cw & ~y_dw | ~x_dw & y_cw;
 unsigned long dw = cw | x_dw | y_dw;
 set_words_( x, i, dw, cw );
    }

    return x;
}




template <class X, class Y>
inline
X&
b_xor_assign_( sc_proxy<X>& a, const sc_proxy<Y>& b )
{
    X& x = a.back_cast();
    const Y& y = b.back_cast();
    (static_cast<void> ((x.length() == y.length()) ? 0 : (__assert_fail ("x.length() == y.length()", "../../../src/systemc/datatypes/bit/sc_proxy.h", 885, __PRETTY_FUNCTION__), 0)));
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 unsigned long x_dw, x_cw, y_dw, y_cw;
 get_words_( x, i, x_dw, x_cw );
 get_words_( y, i, y_dw, y_cw );
 unsigned long cw = x_cw | y_cw;
 unsigned long dw = cw | x_dw ^ y_dw;
 set_words_( x, i, dw, cw );
    }

    return x;
}




template <class X>
inline
X&
sc_proxy<X>::operator <<= ( int n )
{
    X& x = back_cast();
    if( n < 0 ) {
 char msg[8192];
 sprintf( msg,
   "left shift operation is only allowed with positive "
   "shift values, shift value = %d", n );
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, msg, "../../../src/systemc/datatypes/bit/sc_proxy.h", 913 );
    }
    if( n >= x.length() ) {
 extend_sign_w_( x, 0, false );

 return x;
    }
    int sz = x.size();
    int wn = n / UL_SIZE;
    int bn = n % UL_SIZE;
    if( wn != 0 ) {

 int i = sz - 1;
 for( ; i >= wn; -- i ) {
     set_words_( x, i, x.get_word( i - wn ), x.get_cword( i - wn ) );
 }
 for( ; i >= 0; -- i ) {
     set_words_( x, i, UL_ZERO, UL_ZERO );
 }
    }
    if( bn != 0 ) {

 for( int i = sz - 1; i >= 1; -- i ) {
     unsigned long x_dw, x_cw;
     get_words_( x, i, x_dw, x_cw );
     x_dw <<= bn;
     x_dw |= x.get_word( i - 1 ) >> (UL_SIZE - bn);
     x_cw <<= bn;
     x_cw |= x.get_cword( i - 1 ) >> (UL_SIZE - bn);
     set_words_( x, i, x_dw, x_cw );
 }
 unsigned long x_dw, x_cw;
 get_words_( x, 0, x_dw, x_cw );
 x_dw <<= bn;
 x_cw <<= bn;
 set_words_( x, 0, x_dw, x_cw );
    }
    x.clean_tail();
    return x;
}





template <class X>
inline
X&
sc_proxy<X>::operator >>= ( int n )
{
    X& x = back_cast();
    if( n < 0 ) {
 char msg[8192];
 sprintf( msg,
   "right shift operation is only allowed with positive "
   "shift values, shift value = %d", n );
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, msg, "../../../src/systemc/datatypes/bit/sc_proxy.h", 969 );
    }
    if( n >= x.length() ) {
 extend_sign_w_( x, 0, false );

 return x;
    }
    int sz = x.size();
    int wn = n / UL_SIZE;
    int bn = n % UL_SIZE;
    if( wn != 0 ) {

 int i = 0;
 for( ; i < (sz - wn); ++ i ) {
     set_words_( x, i, x.get_word( i + wn ), x.get_cword( i + wn ) );
 }
 for( ; i < sz; ++ i ) {
     set_words_( x, i, UL_ZERO, UL_ZERO );
 }
    }
    if( bn != 0 ) {

 for( int i = 0; i < (sz - 1); ++ i ) {
     unsigned long x_dw, x_cw;
     get_words_( x, i, x_dw, x_cw );
     x_dw >>= bn;
     x_dw |= x.get_word( i + 1 ) << (UL_SIZE - bn);
     x_cw >>= bn;
     x_cw |= x.get_cword( i + 1 ) << (UL_SIZE - bn);
     set_words_( x, i, x_dw, x_cw );
 }
 unsigned long x_dw, x_cw;
 get_words_( x, sz - 1, x_dw, x_cw );
 x_dw >>= bn;
 x_cw >>= bn;
 set_words_( x, sz - 1, x_dw, x_cw );
    }
    x.clean_tail();
    return x;
}




template <class X>
inline
const sc_lv_base
lrotate( const sc_proxy<X>& x, int n );




template <class X>
inline
const sc_lv_base
rrotate( const sc_proxy<X>& x, int n );




template <class X>
inline
X&
sc_proxy<X>::reverse()
{
    X& x = back_cast();
    int len = x.length();
    int half_len = len / 2;
    for( int i = 0, j = len - 1; i < half_len; ++ i, --j ) {
 sc_logic_value_t t = x.get_bit( i );
 x.set_bit( i, x.get_bit( j ) );
 x.set_bit( j, t );
    }
    return x;
}

template <class X>
inline
const sc_lv_base
reverse( const sc_proxy<X>& a );




template <class X>
inline
sc_logic_value_t
sc_proxy<X>::and_reduce() const
{
    const X& x = back_cast();
    sc_logic_value_t result = sc_logic_value_t( 1 );
    int len = x.length();
    for( int i = 0; i < len; ++ i ) {
 result = sc_logic::and_table[result][x.get_bit( i )];
    }
    return result;
}

template <class X>
inline
sc_logic_value_t
sc_proxy<X>::or_reduce() const
{
    const X& x = back_cast();
    sc_logic_value_t result = sc_logic_value_t( 0 );
    int len = x.length();
    for( int i = 0; i < len; ++ i ) {
 result = sc_logic::or_table[result][x.get_bit( i )];
    }
    return result;
}

template <class X>
inline
sc_logic_value_t
sc_proxy<X>::xor_reduce() const
{
    const X& x = back_cast();
    sc_logic_value_t result = sc_logic_value_t( 0 );
    int len = x.length();
    for( int i = 0; i < len; ++ i ) {
 result = sc_logic::xor_table[result][x.get_bit( i )];
    }
    return result;
}




template <class X, class Y>
inline
bool
operator != ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    return !( px == py );
}
# 1132 "../../../src/systemc/datatypes/bit/sc_proxy.h"
template <class X> inline bool operator == ( const char* b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const char* b ) { return !( px == b ); } template <class X> inline bool operator != ( const char* b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const bool* b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const bool* b ) { return !( px == b ); } template <class X> inline bool operator != ( const bool* b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const sc_logic* b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_logic* b ) { return !( px == b ); } template <class X> inline bool operator != ( const sc_logic* b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const sc_unsigned& b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_unsigned& b ) { return !( px == b ); } template <class X> inline bool operator != ( const sc_unsigned& b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const sc_signed& b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_signed& b ) { return !( px == b ); } template <class X> inline bool operator != ( const sc_signed& b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const sc_uint_base& b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_uint_base& b ) { return !( px == b ); } template <class X> inline bool operator != ( const sc_uint_base& b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( const sc_int_base& b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, const sc_int_base& b ) { return !( px == b ); } template <class X> inline bool operator != ( const sc_int_base& b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( unsigned long b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, unsigned long b ) { return !( px == b ); } template <class X> inline bool operator != ( unsigned long b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( long b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, long b ) { return !( px == b ); } template <class X> inline bool operator != ( long b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( unsigned int b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, unsigned int b ) { return !( px == b ); } template <class X> inline bool operator != ( unsigned int b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( int b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, int b ) { return !( px == b ); } template <class X> inline bool operator != ( int b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( uint64 b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, uint64 b ) { return !( px == b ); } template <class X> inline bool operator != ( uint64 b, const sc_proxy<X>& px ) { return !( px == b ); }
template <class X> inline bool operator == ( int64 b, const sc_proxy<X>& px ) { return ( px == b ); } template <class X> inline bool operator != ( const sc_proxy<X>& px, int64 b ) { return !( px == b ); } template <class X> inline bool operator != ( int64 b, const sc_proxy<X>& px ) { return !( px == b ); }






template <class X>
inline
const sc_string
sc_proxy<X>::to_string() const
{
    const X& x = back_cast();
    int len = x.length();
    sc_string s( len + 1 );
    for( int i = 0; i < len; ++ i ) {
 s[i] = sc_logic::logic_to_char[x.get_bit( len - i - 1 )];
    }
    s[len] = 0;
    return s;
}

template <class X>
inline
const sc_string
sc_proxy<X>::to_string( sc_numrep numrep ) const
{
    return convert_to_fmt( to_string(), numrep, true );
}

template <class X>
inline
const sc_string
sc_proxy<X>::to_string( sc_numrep numrep, bool w_prefix ) const
{
    return convert_to_fmt( to_string(), numrep, w_prefix );
}




template <class X>
inline
void
sc_proxy<X>::scan( istream& is )
{
    sc_string s;
    is >> s;
    back_cast() = s.c_str();
}


template <class X>
inline
void
sc_proxy<X>::check_bounds( int n ) const
{
    if( n < 0 || n >= back_cast().length() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1202 );
    }
}

template <class X>
inline
void
sc_proxy<X>::check_wbounds( int n ) const
{
    if( n < 0 || n >= back_cast().size() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1212 );
    }
}


template <class X>
inline
unsigned long
sc_proxy<X>::to_anything_unsigned() const
{


    const X& x = back_cast();
    int len = x.length();
    if( x.get_cword( 0 ) != UL_ZERO ) {
 sc_report_handler::report( SC_WARNING, SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1227 );
    }
    unsigned long w = x.get_word( 0 );
    if( len >= UL_SIZE ) {
 return w;
    }
    return ( w & (~UL_ZERO >> (UL_SIZE - len)) );
}

template <class X>
inline
uint64
sc_proxy<X>::to_uint64() const
{


    const X& x = back_cast();
    int len = x.length();
    if( x.get_cword( 0 ) != UL_ZERO ) {
 sc_report_handler::report( SC_WARNING, SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1246 );
    }
    uint64 w = x.get_word( 0 );
    if( len > UL_SIZE )
    {
 if( x.get_cword( 1 ) != UL_ZERO ) {
     sc_report_handler::report( SC_WARNING, SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1252 );
 }
        w = (w << UL_SIZE) | x.get_word( 1 );
 return w;
    }
    else if( len == UL_SIZE )
    {
 return w;
    }
    else
    {
 return ( w & (~UL_ZERO >> (UL_SIZE - len)) );
    }
}

template <class X>
inline
long
sc_proxy<X>::to_anything_signed() const
{


    const X& x = back_cast();
    int len = x.length();
    if( x.get_cword( 0 ) != UL_ZERO ) {
 sc_report_handler::report( SC_WARNING, SC_ID_VECTOR_CONTAINS_LOGIC_VALUE_, 0, "../../../src/systemc/datatypes/bit/sc_proxy.h", 1277 );
    }
    unsigned long w = x.get_word( 0 );
    if( len >= UL_SIZE ) {
 return (long) w;
    }
    sc_logic_value_t sgn = x.get_bit( len - 1 );
    if( sgn == 0 ) {
 return ( w & (~UL_ZERO >> (UL_SIZE - len)) );
    } else {
 return ( w | (~UL_ZERO << len) );
    }
}






template <class X>
inline
sc_logic_value_t
and_reduce( const sc_proxy<X>& a )
{
    return a.and_reduce();
}

template <class X>
inline
sc_logic_value_t
nand_reduce( const sc_proxy<X>& a )
{
    return a.nand_reduce();
}

template <class X>
inline
sc_logic_value_t
or_reduce( const sc_proxy<X>& a )
{
    return a.or_reduce();
}

template <class X>
inline
sc_logic_value_t
nor_reduce( const sc_proxy<X>& a )
{
    return a.nor_reduce();
}

template <class X>
inline
sc_logic_value_t
xor_reduce( const sc_proxy<X>& a )
{
    return a.xor_reduce();
}

template <class X>
inline
sc_logic_value_t
xnor_reduce( const sc_proxy<X>& a )
{
    return a.xnor_reduce();
}




template <class X>
inline
ostream&
operator << ( ostream& os, const sc_proxy<X>& a )
{
    a.print( os );
    return os;
}

template <class X>
inline
istream&
operator >> ( istream& is, sc_proxy<X>& a )
{
    a.scan( is );
    return is;
}

}
# 42 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h" 2


namespace sc_dt
{


template <class X> class sc_bitref_r;
template <class X> class sc_bitref;
template <class X> class sc_subref_r;
template <class X> class sc_subref;
template <class X, class Y> class sc_concref_r;
template <class X, class Y> class sc_concref;
# 62 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T>
class sc_bitref_r
{
    friend class sc_bv_base;
    friend class sc_lv_base;

public:



    sc_bitref_r( const T& obj_, int index_ )
 : m_obj( const_cast<T&>( obj_ ) ), m_index( index_ )
 {}




    sc_bitref_r( const sc_bitref_r<T>& a )
 : m_obj( a.m_obj ), m_index( a.m_index )
 {}




    sc_bitref_r<T>* clone() const
 { return new sc_bitref_r<T>( *this ); }






    const sc_logic operator ~ () const
 { return sc_logic( sc_logic::not_table[value()] ); }




    operator const sc_logic() const
 { return sc_logic( m_obj.get_bit( m_index ) ); }




    sc_logic_value_t value() const
 { return m_obj.get_bit( m_index ); }


    bool is_01() const
 { return sc_logic( value() ).is_01(); }

    bool to_bool() const
 { return sc_logic( value() ).to_bool(); }

    char to_char() const
 { return sc_logic( value() ).to_char(); }




    int length() const
 { return 1; }

    int size() const
 { return ( (length() - 1) / UL_SIZE + 1 ); }

    sc_logic_value_t get_bit( int n ) const;

    unsigned long get_word( int i ) const;
    unsigned long get_cword( int i ) const;




    void print( ostream& os = cout ) const
 { os << to_char(); }

protected:

    T& m_obj;
    int m_index;

private:


    sc_bitref_r();
    sc_bitref_r<T>& operator = ( const sc_bitref_r<T>& );
};






template <class T1, class T2>
inline
const sc_logic
operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );




template <class T1, class T2>
inline
const sc_logic
operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );




template <class T1, class T2>
inline
const sc_logic
operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );




template <class T1, class T2>
inline
bool
operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );

template <class T1, class T2>
inline
bool
operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b );




template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref_r<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref_r<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref_r<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref_r<T1>, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const char*, sc_bitref_r<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const sc_logic&, sc_bitref_r<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( bool, sc_bitref_r<T> );


template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref_r<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref_r<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref_r<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref_r<T1>, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const char*, sc_bitref_r<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const sc_logic&, sc_bitref_r<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( bool, sc_bitref_r<T> );




template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref_r<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref_r<T1>, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref_r<T1>, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref<T1>, const sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref_r<T1>, sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const char*, sc_bitref<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const sc_logic&, sc_bitref<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( bool, sc_bitref<T> );


template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref_r<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref_r<T1>, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref_r<T1>, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref<T1>, const sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref_r<T1>, sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const char*, sc_bitref<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const sc_logic&, sc_bitref<T> );

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( bool, sc_bitref<T> );
# 447 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X>
class sc_bitref
    : public sc_bitref_r<X>
{
    friend class sc_bv_base;
    friend class sc_lv_base;

public:



    sc_bitref( X& obj_, int index_ )
 : sc_bitref_r<X>( obj_, index_ )
 {}




    sc_bitref( const sc_bitref<X>& a )
 : sc_bitref_r<X>( a )
 {}




    sc_bitref<X>* clone() const
 { return new sc_bitref<X>( *this ); }




    sc_bitref<X>& operator = ( const sc_bitref_r<X>& a );
    sc_bitref<X>& operator = ( const sc_bitref<X>& a );

    sc_bitref<X>& operator = ( const sc_logic& a )
 { this->m_obj.set_bit( this->m_index, a.value() ); return *this; }

    sc_bitref<X>& operator = ( sc_logic_value_t v )
 { *this = sc_logic( v ); return *this; }

    sc_bitref<X>& operator = ( bool a )
 { *this = sc_logic( a ); return *this; }

    sc_bitref<X>& operator = ( char a )
 { *this = sc_logic( a ); return *this; }

    sc_bitref<X>& operator = ( int a )
 { *this = sc_logic( a ); return *this; }

    sc_bitref<X>& operator = ( const sc_bit& a )
 { *this = sc_logic( a ); return *this; }




    sc_bitref<X>& operator &= ( const sc_bitref_r<X>& a );
    sc_bitref<X>& operator &= ( const sc_logic& a );

    sc_bitref<X>& operator &= ( sc_logic_value_t v )
 { *this &= sc_logic( v ); return *this; }

    sc_bitref<X>& operator &= ( bool a )
 { *this &= sc_logic( a ); return *this; }

    sc_bitref<X>& operator &= ( char a )
 { *this &= sc_logic( a ); return *this; }

    sc_bitref<X>& operator &= ( int a )
 { *this &= sc_logic( a ); return *this; }


    sc_bitref<X>& operator |= ( const sc_bitref_r<X>& a );
    sc_bitref<X>& operator |= ( const sc_logic& a );

    sc_bitref<X>& operator |= ( sc_logic_value_t v )
 { *this |= sc_logic( v ); return *this; }

    sc_bitref<X>& operator |= ( bool a )
 { *this |= sc_logic( a ); return *this; }

    sc_bitref<X>& operator |= ( char a )
 { *this |= sc_logic( a ); return *this; }

    sc_bitref<X>& operator |= ( int a )
 { *this |= sc_logic( a ); return *this; }


    sc_bitref<X>& operator ^= ( const sc_bitref_r<X>& a );
    sc_bitref<X>& operator ^= ( const sc_logic& a );

    sc_bitref<X>& operator ^= ( sc_logic_value_t v )
 { *this ^= sc_logic( v ); return *this; }

    sc_bitref<X>& operator ^= ( bool a )
 { *this ^= sc_logic( a ); return *this; }

    sc_bitref<X>& operator ^= ( char a )
 { *this ^= sc_logic( a ); return *this; }

    sc_bitref<X>& operator ^= ( int a )
 { *this ^= sc_logic( a ); return *this; }






    sc_bitref<X>& b_not();




    void set_bit( int n, sc_logic_value_t value );

    void set_word( int i, unsigned long w );
    void set_cword( int i, unsigned long w );

    void clean_tail()
 { this->m_obj.clean_tail(); }




    void scan( istream& is = cin );

private:


    sc_bitref();
};




template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_bitref<T2> >
operator , ( sc_bitref<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_subref<T2> >
operator , ( sc_bitref<T1>, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
operator , ( sc_bitref<T1>, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,T2>
operator , ( sc_bitref<T1>, sc_proxy<T2>& );


template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_bitref<T2> >
concat( sc_bitref<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_subref<T2> >
concat( sc_bitref<T1>, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
concat( sc_bitref<T1>, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,T2>
concat( sc_bitref<T1>, sc_proxy<T2>& );


template <class T>
istream&
operator >> ( istream&, sc_bitref<T> );
# 634 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X>
class sc_subref_r
    : public sc_proxy<sc_subref_r<X> >
{
    void check_bounds();

public:



    sc_subref_r( const X& obj_, int hi_, int lo_ )
 : m_obj( const_cast<X&>( obj_ ) ), m_hi( hi_ ), m_lo( lo_ ), m_len( 0 )
 { check_bounds(); }




    sc_subref_r( const sc_subref_r<X>& a )
 : m_obj( a.m_obj ), m_hi( a.m_hi ), m_lo( a.m_lo ), m_len( a.m_len )
 {}




    sc_subref_r<X>* clone() const
 { return new sc_subref_r<X>( *this ); }




    int length() const
 { return m_len; }

    int size() const
 { return ( (length() - 1) / UL_SIZE + 1 ); }

    sc_logic_value_t get_bit( int n ) const;
    void set_bit( int n, sc_logic_value_t value );

    unsigned long get_word( int i )const;
    void set_word( int i, unsigned long w );

    unsigned long get_cword( int i ) const;
    void set_cword( int i, unsigned long w );

    void clean_tail()
 { m_obj.clean_tail(); }




    bool is_01() const;

    bool reversed() const
 { return m_lo > m_hi; }

protected:

    mutable X& m_obj;
    int m_hi;
    int m_lo;
    int m_len;

private:


    sc_subref_r();
    sc_subref_r<X>& operator = ( const sc_subref_r<X>& );
};




template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref_r<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref_r<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref_r<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref_r<T1>, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const char*, sc_subref_r<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const sc_logic&, sc_subref_r<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( bool, sc_subref_r<T> );


template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref_r<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref_r<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref_r<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref_r<T1>, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const char*, sc_subref_r<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const sc_logic&, sc_subref_r<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( bool, sc_subref_r<T> );




template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref_r<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref_r<T1>, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref_r<T1>, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref<T1>, const sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref_r<T1>, sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const char*, sc_subref<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const sc_logic&, sc_subref<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( bool, sc_subref<T> );


template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref_r<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref<T1>, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref_r<T1>, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref<T1>, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref_r<T1>, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref<T1>, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref<T1>, const sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref_r<T1>, sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T>, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const char*, sc_subref<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T>, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const sc_logic&, sc_subref<T> );

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T>, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( bool, sc_subref<T> );
# 961 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X>
class sc_subref
    : public sc_subref_r<X>
{
public:



    typedef sc_subref_r<X> base_type;




    sc_subref( X& obj_, int hi_, int lo_ )
 : sc_subref_r<X>( obj_, hi_, lo_ )
 {}




    sc_subref( const sc_subref<X>& a )
 : sc_subref_r<X>( a )
 {}




    sc_subref<X>* clone() const
 { return new sc_subref<X>( *this ); }




    template <class Y>
    sc_subref<X>& operator = ( const sc_proxy<Y>& a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_subref_r<X>& a );
    sc_subref<X>& operator = ( const sc_subref<X>& a );

    sc_subref<X>& operator = ( const char* a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const bool* a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_logic* a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_unsigned& a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_signed& a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_uint_base& a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( const sc_int_base& a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( unsigned long a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( long a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( unsigned int a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( int a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( uint64 a )
 { base_type::assign_( a ); return *this; }

    sc_subref<X>& operator = ( int64 a )
 { base_type::assign_( a ); return *this; }




    void scan( istream& = cin );

private:


    sc_subref();
};




template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_bitref<T2> >
operator , ( sc_subref<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_subref<T2> >
operator , ( sc_subref<T1>, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
operator , ( sc_subref<T1>, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,T2>
operator , ( sc_subref<T1>, sc_proxy<T2>& );


template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_bitref<T2> >
concat( sc_subref<T1>, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_subref<T2> >
concat( sc_subref<T1>, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
concat( sc_subref<T1>, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,T2>
concat( sc_subref<T1>, sc_proxy<T2>& );


template <class T>
inline
istream&
operator >> ( istream&, sc_subref<T> );
# 1108 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X, class Y>
class sc_concref_r
    : public sc_proxy<sc_concref_r<X,Y> >
{
public:



    sc_concref_r( const X& left_, const Y& right_, int delete_ = 0 )
 : m_left( const_cast<X&>( left_ ) ), m_right( const_cast<Y&>( right_ ) ),
   m_delete( delete_ ), m_refs( *new int( 1 ) )
 {}




    sc_concref_r( const sc_concref_r<X,Y>& a )
 : m_left( a.m_left ), m_right( a.m_right ),
   m_delete( a.m_delete ), m_refs( a.m_refs )
 { ++ m_refs; }




    virtual ~sc_concref_r();




    sc_concref_r<X,Y>* clone() const
 { return new sc_concref_r<X,Y>( *this ); }




    int length() const
 { return ( m_left.length() + m_right.length() ); }

    int size() const
 { return ( (length() - 1) / UL_SIZE + 1 ); }

    sc_logic_value_t get_bit( int n ) const;
    void set_bit( int n, sc_logic_value_t value );

    unsigned long get_word( int i ) const;
    void set_word( int i, unsigned long w );

    unsigned long get_cword( int i ) const;
    void set_cword( int i, unsigned long w );

    void clean_tail()
 { m_left.clean_tail(); m_right.clean_tail(); }




    bool is_01() const
 { return ( m_left.is_01() && m_right.is_01() ); }

protected:

    mutable X& m_left;
    mutable Y& m_right;
    mutable int m_delete;
    mutable int& m_refs;

private:


    sc_concref_r();
    sc_concref_r<X,Y>& operator = ( const sc_concref_r<X,Y>& );
};




template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref_r<T1,T2>, sc_bitref_r<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref_r<T1,T2>, sc_subref_r<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref_r<T1,T2>, const sc_proxy<T3>& );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2>, const char* );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const char*, sc_concref_r<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2>, const sc_logic& );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const sc_logic&, sc_concref_r<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2>, bool );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( bool, sc_concref_r<T1,T2> );


template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref_r<T1,T2>, sc_bitref_r<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref_r<T1,T2>, sc_subref_r<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref_r<T1,T2>, sc_concref_r<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref_r<T1,T2>, const sc_proxy<T3>& );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2>, const char* );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const char*, sc_concref_r<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2>, const sc_logic& );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const sc_logic&, sc_concref_r<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2>, bool );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( bool, sc_concref_r<T1,T2> );




template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref_r<T1,T2>, sc_bitref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref<T1,T2>, sc_bitref_r<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref_r<T1,T2>, sc_subref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref<T1,T2>, sc_subref_r<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref_r<T1,T2>, sc_concref<T3,T4> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref<T1,T2>, sc_concref_r<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref<T1,T2>, const sc_proxy<T3>& );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref_r<T1,T2>, sc_proxy<T3>& );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2>, const char* );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const char*, sc_concref<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2>, const sc_logic& );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const sc_logic&, sc_concref<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2>, bool );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( bool, sc_concref<T1,T2> );


template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref_r<T1,T2>, sc_bitref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref<T1,T2>, sc_bitref_r<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref_r<T1,T2>, sc_subref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref<T1,T2>, sc_subref_r<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref_r<T1,T2>, sc_concref<T3,T4> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref<T1,T2>, sc_concref_r<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref<T1,T2>, const sc_proxy<T3>& );

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref_r<T1,T2>, sc_proxy<T3>& );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2>, const char* );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const char*, sc_concref<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2>, const sc_logic& );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const sc_logic&, sc_concref<T1,T2> );

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2>, bool );

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( bool, sc_concref<T1,T2> );
# 1438 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X, class Y>
class sc_concref
    : public sc_concref_r<X,Y>
{
public:



    typedef sc_concref_r<X,Y> base_type;




    sc_concref( X& left_, Y& right_, int delete_ = 0 )
 : sc_concref_r<X,Y>( left_, right_, delete_ )
 {}




    sc_concref( const sc_concref<X,Y>& a )
 : sc_concref_r<X,Y>( a )
 {}




    sc_concref<X,Y>* clone() const
 { return new sc_concref<X,Y>( *this ); }




    template <class Z>
    sc_concref<X,Y>& operator = ( const sc_proxy<Z>& a )
        { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_concref<X,Y>& a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const char* a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const bool* a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_logic* a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_unsigned& a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_signed& a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_uint_base& a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( const sc_int_base& a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( unsigned long a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( long a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( unsigned int a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( int a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( uint64 a )
 { base_type::assign_( a ); return *this; }

    sc_concref<X,Y>& operator = ( int64 a )
 { base_type::assign_( a ); return *this; }




    void scan( istream& = cin );

private:


    sc_concref();
};




template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
operator , ( sc_concref<T1,T2>, sc_bitref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
operator , ( sc_concref<T1,T2>, sc_subref<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
operator , ( sc_concref<T1,T2>, sc_concref<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,T3>
operator , ( sc_concref<T1,T2>, sc_proxy<T3>& );


template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
concat( sc_concref<T1,T2>, sc_bitref<T3> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
concat( sc_concref<T1,T2>, sc_subref<T3> );

template <class T1, class T2, class T3, class T4>
inline
sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
concat( sc_concref<T1,T2>, sc_concref<T3,T4> );

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,T3>
concat( sc_concref<T1,T2>, sc_proxy<T3>& );


template <class T1, class T2>
inline
istream&
operator >> ( istream&, sc_concref<T1,T2> );
# 1588 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( const sc_proxy<T1>&, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( const sc_proxy<T1>&, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( const sc_proxy<T1>&, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( const sc_proxy<T1>&, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>&, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const char*, const sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>&, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const sc_logic&, const sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>&, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( bool, const sc_proxy<T>& );


template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( const sc_proxy<T1>&, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( const sc_proxy<T1>&, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( const sc_proxy<T1>&, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( const sc_proxy<T1>&, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>&, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const char*, const sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>&, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const sc_logic&, const sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>&, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( bool, const sc_proxy<T>& );




template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( const sc_proxy<T1>&, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( sc_proxy<T1>&, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( const sc_proxy<T1>&, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( sc_proxy<T1>&, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( const sc_proxy<T1>&, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( sc_proxy<T1>&, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( const sc_proxy<T1>&, sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( sc_proxy<T1>&, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>&, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const char*, sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>&, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const sc_logic&, sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>&, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( bool, sc_proxy<T>& );


template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( const sc_proxy<T1>&, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( sc_proxy<T1>&, sc_bitref_r<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( const sc_proxy<T1>&, sc_subref<T2> );

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( sc_proxy<T1>&, sc_subref_r<T2> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( const sc_proxy<T1>&, sc_concref<T2,T3> );

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( sc_proxy<T1>&, sc_concref_r<T2,T3> );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( const sc_proxy<T1>&, sc_proxy<T2>& );

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( sc_proxy<T1>&, const sc_proxy<T2>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>&, const char* );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const char*, sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>&, const sc_logic& );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const sc_logic&, sc_proxy<T>& );

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>&, bool );

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( bool, sc_proxy<T>& );






template <class T1, class T2>
inline
sc_concref<T1,sc_bitref<T2> >
operator , ( sc_proxy<T1>&, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<T1,sc_subref<T2> >
operator , ( sc_proxy<T1>&, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<T1,sc_concref<T2,T3> >
operator , ( sc_proxy<T1>&, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<T1,T2>
operator , ( sc_proxy<T1>&, sc_proxy<T2>& );


template <class T1, class T2>
inline
sc_concref<T1,sc_bitref<T2> >
concat( sc_proxy<T1>&, sc_bitref<T2> );

template <class T1, class T2>
inline
sc_concref<T1,sc_subref<T2> >
concat( sc_proxy<T1>&, sc_subref<T2> );

template <class T1, class T2, class T3>
inline
sc_concref<T1,sc_concref<T2,T3> >
concat( sc_proxy<T1>&, sc_concref<T2,T3> );

template <class T1, class T2>
inline
sc_concref<T1,T2>
concat( sc_proxy<T1>&, sc_proxy<T2>& );
# 1892 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T1, class T2>
inline
const sc_logic
operator & ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
{
    return sc_logic( sc_logic::and_table[a.value()][b.value()] );
}




template <class T1, class T2>
inline
const sc_logic
operator | ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
{
    return sc_logic( sc_logic::or_table[a.value()][b.value()] );
}




template <class T1, class T2>
inline
const sc_logic
operator ^ ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
{
    return sc_logic( sc_logic::xor_table[a.value()][b.value()] );
}




template <class T1, class T2>
inline
bool
operator == ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
{
    return ( (int) a.value() == b.value() );
}

template <class T1, class T2>
inline
bool
operator != ( const sc_bitref_r<T1>& a, const sc_bitref_r<T2>& b )
{
    return ( (int) a.value() != b.value() );
}




template <class T>
inline
sc_logic_value_t
sc_bitref_r<T>::get_bit( int n ) const
{
    if( n == 0 ) {
 return m_obj.get_bit( m_index );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 1952 );

 return Log_0;
    }
}


template <class T>
inline
unsigned long
sc_bitref_r<T>::get_word( int n ) const
{
    if( n == 0 ) {
 return ( get_bit( n ) & UL_ONE );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 1967 );

 return 0;
    }
}

template <class T>
inline
unsigned long
sc_bitref_r<T>::get_cword( int n ) const
{
    if( n == 0 ) {
 return ( get_bit( n ) & UL_TWO );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 1981 );

 return 0;
    }
}




template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref_r<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref_r<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref_r<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref_r<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref_r<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref_r<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref_r<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}




template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref_r<T1> a, sc_bitref<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_bitref<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref_r<T1> a, sc_subref<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
operator , ( sc_bitref<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref_r<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_bitref<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
operator , ( sc_bitref_r<T1> a, sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref_r<T1> a, sc_bitref<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >
concat( sc_bitref<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref_r<T1> a, sc_subref<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >
concat( sc_bitref<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref_r<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_bitref<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_bitref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_bitref_r<T1>,T2>
concat( sc_bitref_r<T1> a, sc_proxy<T2>& b )
{
    return sc_concref_r<sc_bitref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}
# 2222 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator = ( const sc_bitref_r<X>& a )
{
    this->m_obj.set_bit( this->m_index, a.value() );
 return *this;
}

template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator = ( const sc_bitref<X>& a )
{
    if( &a != this ) {
 this->m_obj.set_bit( this->m_index, a.value() );
    }
    return *this;
}




template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator &= ( const sc_bitref_r<X>& a )
{
    if( &a != this ) {
 this->m_obj.set_bit( this->m_index,
        sc_logic::and_table[this->value()][a.value()] );
    }
    return *this;
}

template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator &= ( const sc_logic& a )
{
    this->m_obj.set_bit( this->m_index,
    sc_logic::and_table[this->value()][a.value()] );
    return *this;
}


template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator |= ( const sc_bitref_r<X>& a )
{
    if( &a != this ) {
 this->m_obj.set_bit( this->m_index,
        sc_logic::or_table[this->value()][a.value()] );
    }
    return *this;
}

template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator |= ( const sc_logic& a )
{
    this->m_obj.set_bit( this->m_index,
    sc_logic::or_table[this->value()][a.value()] );
    return *this;
}


template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator ^= ( const sc_bitref_r<X>& a )
{
    if( &a != this ) {
 this->m_obj.set_bit( this->m_index,
        sc_logic::xor_table[this->value()][a.value()] );
    }
    return *this;
}

template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::operator ^= ( const sc_logic& a )
{
    this->m_obj.set_bit( this->m_index,
    sc_logic::xor_table[this->value()][a.value()] );
    return *this;
}






template <class X>
inline
sc_bitref<X>&
sc_bitref<X>::b_not()
{
    this->m_obj.set_bit( this->m_index,
    sc_logic::not_table[this->value()] );
    return *this;
}




template <class X>
inline
void
sc_bitref<X>::set_bit( int n, sc_logic_value_t value )
{
    if( n == 0 ) {
 this->m_obj.set_bit( this->m_index, value );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 2339 );
    }
}


template <class X>
inline
void
sc_bitref<X>::set_word( int n, unsigned long w )
{
    if( n == 0 ) {
 this->m_obj.set_word( this->m_index, w );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 2352 );
    }
}

template <class X>
inline
void
sc_bitref<X>::set_cword( int n, unsigned long w )
{
    if( n == 0 ) {
 this->m_obj.set_cword( this->m_index, w );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 2364 );
    }
}




template <class X>
inline
void
sc_bitref<X>::scan( istream& is )
{
    char c;
    is >> c;
    *this = c;
}




template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_bitref<T2> >
operator , ( sc_bitref<T1> a, sc_bitref<T2> b )
{
    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_subref<T2> >
operator , ( sc_bitref<T1> a, sc_subref<T2> b )
{
    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
operator , ( sc_bitref<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,T2>
operator , ( sc_bitref<T1> a, sc_proxy<T2>& b )
{
    return sc_concref<sc_bitref<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_bitref<T2> >
concat( sc_bitref<T1> a, sc_bitref<T2> b )
{
    return sc_concref<sc_bitref<T1>,sc_bitref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,sc_subref<T2> >
concat( sc_bitref<T1> a, sc_subref<T2> b )
{
    return sc_concref<sc_bitref<T1>,sc_subref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >
concat( sc_bitref<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref<sc_bitref<T1>,sc_concref<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_bitref<T1>,T2>
concat( sc_bitref<T1> a, sc_proxy<T2>& b )
{
    return sc_concref<sc_bitref<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class X>
inline
istream&
operator >> ( istream& is, sc_bitref<X> a )
{
    a.scan( is );
    return is;
}
# 2474 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X>
inline
void
sc_subref_r<X>::check_bounds()
{
    int len = m_obj.length();
    if( m_hi < 0 || m_hi >= len || m_lo < 0 || m_lo >= len ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 2481 );
    }
    if( reversed() ) {
 m_len = m_lo - m_hi + 1;
    } else {
 m_len = m_hi - m_lo + 1;
    }
}




template <class X>
inline
sc_logic_value_t
sc_subref_r<X>::get_bit( int n ) const
{
    if( reversed() ) {
 return m_obj.get_bit( m_lo - n );
    } else {
 return m_obj.get_bit( m_lo + n );
    }
}

template <class X>
inline
void
sc_subref_r<X>::set_bit( int n, sc_logic_value_t value )
{
    if( reversed() ) {
 m_obj.set_bit( m_lo - n, value );
    } else {
 m_obj.set_bit( m_lo + n, value );
    }
}


template <class X>
inline
unsigned long
sc_subref_r<X>::get_word( int i ) const
{
    int n1 = 0;
    int n2 = 0;
    unsigned long result = 0;
    int k = 0;
    if( reversed() ) {
 n1 = m_lo - i * UL_SIZE;
 n2 = sc_max( n1 - UL_SIZE, m_hi - 1 );
 for( int n = n1; n > n2; n -- ) {
     result |= (m_obj[n].value() & UL_ONE) << k ++;
 }
    } else {
 n1 = m_lo + i * UL_SIZE;
 n2 = sc_min( n1 + UL_SIZE, m_hi + 1 );
 for( int n = n1; n < n2; n ++ ) {
     result |= (m_obj[n].value() & UL_ONE) << k ++;
 }
    }
    return result;
}

template <class X>
inline
void
sc_subref_r<X>::set_word( int i, unsigned long w )
{
    int n1 = 0;
    int n2 = 0;
    int k = 0;
    if( reversed() ) {
 n1 = m_lo - i * UL_SIZE;
 n2 = sc_max( n1 - UL_SIZE, m_hi - 1 );
 for( int n = n1; n > n2; n -- ) {
     m_obj.set_bit( n, sc_logic_value_t( (w >> k ++) & UL_ONE |
      m_obj[n].value() & UL_TWO ) );
 }
    } else {
 n1 = m_lo + i * UL_SIZE;
 n2 = sc_min( n1 + UL_SIZE, m_hi + 1 );
 for( int n = n1; n < n2; n ++ ) {
     m_obj.set_bit( n, sc_logic_value_t( (w >> k ++) & UL_ONE |
      m_obj[n].value() & UL_TWO ) );
 }
    }
}


template <class X>
inline
unsigned long
sc_subref_r<X>::get_cword( int i ) const
{
    int n1 = 0;
    int n2 = 0;
    unsigned long result = 0;
    int k = 0;
    if( reversed() ) {
 n1 = m_lo - i * UL_SIZE;
 n2 = sc_max( n1 - UL_SIZE, m_hi - 1 );
 for( int n = n1; n > n2; n -- ) {
     result |= ((m_obj[n].value() & UL_TWO) >> 1) << k ++;
 }
    } else {
 n1 = m_lo + i * UL_SIZE;
 n2 = sc_min( n1 + UL_SIZE, m_hi + 1 );
 for( int n = n1; n < n2; n ++ ) {
     result |= ((m_obj[n].value() & UL_TWO) >> 1) << k ++;
 }
    }
    return result;
}

template <class X>
inline
void
sc_subref_r<X>::set_cword( int i, unsigned long w )
{
    int n1 = 0;
    int n2 = 0;
    int k = 0;
    if( reversed() ) {
 n1 = m_lo - i * UL_SIZE;
 n2 = sc_max( n1 - UL_SIZE, m_hi - 1 );
 for( int n = n1; n > n2; n -- ) {
     m_obj.set_bit( n, sc_logic_value_t( ((w >> k ++) & UL_ONE) << 1 |
      m_obj[n].value() & UL_ONE ) );
 }
    } else {
 n1 = m_lo + i * UL_SIZE;
 n2 = sc_min( n1 + UL_SIZE, m_hi + 1 );
 for( int n = n1; n < n2; n ++ ) {
     m_obj.set_bit( n, sc_logic_value_t( ((w >> k ++) & UL_ONE) << 1 |
      m_obj[n].value() & UL_ONE ) );
 }
    }
}




template <class X>
inline
bool
sc_subref_r<X>::is_01() const
{
    int sz = size();
    for( int i = 0; i < sz; ++ i ) {
 if( get_cword( i ) != UL_ZERO ) {
     return false;
 }
    }
    return true;
}




template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref_r<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref_r<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref_r<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref_r<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref_r<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref_r<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref_r<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref_r<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}




template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref_r<T1> a, sc_bitref<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
operator , ( sc_subref<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref_r<T1> a, sc_subref<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
operator , ( sc_subref<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref_r<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
operator , ( sc_subref<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
operator , ( sc_subref_r<T1> a, sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref_r<T1> a, sc_bitref<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >
concat( sc_subref<T1> a, sc_bitref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_bitref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref_r<T1> a, sc_subref<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >
concat( sc_subref<T1> a, sc_subref_r<T2> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_subref_r<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref_r<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >
concat( sc_subref<T1> a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<sc_subref_r<T1>,sc_concref_r<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref<T1> a, const sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_subref_r<T1>,T2>
concat( sc_subref_r<T1> a, sc_proxy<T2>& b )
{
    return sc_concref_r<sc_subref_r<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}
# 2877 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T>
inline
void
sc_subref<T>::scan( istream& is )
{
    sc_string s;
    is >> s;
    *this = s.c_str();
}




template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_bitref<T2> >
operator , ( sc_subref<T1> a, sc_bitref<T2> b )
{
    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_subref<T2> >
operator , ( sc_subref<T1> a, sc_subref<T2> b )
{
    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
operator , ( sc_subref<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,T2>
operator , ( sc_subref<T1> a, sc_proxy<T2>& b )
{
    return sc_concref<sc_subref<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_bitref<T2> >
concat( sc_subref<T1> a, sc_bitref<T2> b )
{
    return sc_concref<sc_subref<T1>,sc_bitref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,sc_subref<T2> >
concat( sc_subref<T1> a, sc_subref<T2> b )
{
    return sc_concref<sc_subref<T1>,sc_subref<T2> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_subref<T1>,sc_concref<T2,T3> >
concat( sc_subref<T1> a, sc_concref<T2,T3> b )
{
    return sc_concref<sc_subref<T1>,sc_concref<T2,T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref<sc_subref<T1>,T2>
concat( sc_subref<T1> a, sc_proxy<T2>& b )
{
    return sc_concref<sc_subref<T1>,T2>(
 *a.clone(), b.back_cast(), 1 );
}


template <class X>
inline
istream&
operator >> ( istream& is, sc_subref<X> a )
{
    a.scan( is );
    return is;
}
# 2982 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class X, class Y>
inline
sc_concref_r<X,Y>::~sc_concref_r()
{
    if( -- m_refs == 0 ) {
 delete &m_refs;
 if( m_delete == 0 ) {
     return;
 }
 if( m_delete & 1 ) {
     delete &m_left;
 }
 if( m_delete & 2 ) {
     delete &m_right;
 }
    }
}




template <class X, class Y>
inline
sc_logic_value_t
sc_concref_r<X,Y>::get_bit( int n ) const
{
    int r_len = m_right.length();
    if( n < r_len ) {
 return m_right.get_bit( n );
    } else if( n < r_len + m_left.length() ) {
 return m_left.get_bit( n - r_len );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3014 );

 return Log_0;
    }
}

template <class X, class Y>
inline
void
sc_concref_r<X,Y>::set_bit( int n, sc_logic_value_t v )
{
    int r_len = m_right.length();
    if( n < r_len ) {
 m_right.set_bit( n, v );
    } else if( n < r_len + m_left.length() ) {
 m_left.set_bit( n - r_len, v );
    } else {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3031 );
    }
}


template <class X, class Y>
inline
unsigned long
sc_concref_r<X,Y>::get_word( int i ) const
{
    if( i < 0 || i >= size() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3042 );
    }

    Y& r = m_right;
    int r_len = r.length();
    int border = r_len / UL_SIZE;
    if( i < border ) {
 return r.get_word( i );
    }

    X& l = m_left;
    int shift = r_len % UL_SIZE;
    int j = i - border;
    if( shift == 0 ) {
 return l.get_word( j );
    }

    int nshift = UL_SIZE - shift;
    if( i == border ) {
 unsigned long rl_mask = ~UL_ZERO >> nshift;
 return ( (r.get_word( i ) & rl_mask) | (l.get_word( 0 ) << shift) );
    }

    return ( (l.get_word( j - 1 ) >> nshift) | (l.get_word( j ) << shift) );
}

template <class X, class Y>
inline
void
sc_concref_r<X,Y>::set_word( int i, unsigned long w )
{
    if( i < 0 || i >= size() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3074 );
    }

    Y& r = m_right;
    int r_len = r.length();
    int border = r_len / UL_SIZE;
    if( i < border ) {
 r.set_word( i, w );
 return;
    }

    X& l = m_left;
    int shift = r_len % UL_SIZE;
    int j = i - border;
    if( shift == 0 ) {
 l.set_word( j, w );
 return;
    }

    int nshift = UL_SIZE - shift;
    unsigned long lh_mask = ~UL_ZERO << nshift;
    if( i == border ) {
 unsigned long rl_mask = ~UL_ZERO >> nshift;
 r.set_word( i, w & rl_mask );
 l.set_word( 0, (l.get_word( 0 ) & lh_mask) | (w >> shift) );
 return;
    }

    unsigned long ll_mask = ~UL_ZERO >> shift;
    l.set_word( j - 1, (l.get_word( j - 1 ) & ll_mask) | (w << nshift) );
    l.set_word( j, (l.get_word( j ) & lh_mask) | (w >> shift) );
}


template <class X, class Y>
inline
unsigned long
sc_concref_r<X,Y>::get_cword( int i ) const
{
    if( i < 0 || i >= size() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3114 );
    }

    Y& r = m_right;
    int r_len = r.length();
    int border = r_len / UL_SIZE;
    if( i < border ) {
 return r.get_cword( i );
    }

    X& l = m_left;
    int shift = r_len % UL_SIZE;
    int j = i - border;
    if( shift == 0 ) {
 return l.get_cword( j );
    }

    int nshift = UL_SIZE - shift;
    if( i == border ) {
 unsigned long rl_mask = ~UL_ZERO >> nshift;
 return ( (r.get_cword( i ) & rl_mask) | (l.get_cword( 0 ) << shift) );
    }

    return ( (l.get_cword( j - 1 ) >> nshift) | (l.get_cword( j ) << shift) );
}

template <class X, class Y>
inline
void
sc_concref_r<X,Y>::set_cword( int i, unsigned long w )
{
    if( i < 0 || i >= size() ) {
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, 0, "../../../src/systemc/datatypes/bit/sc_bit_proxies.h", 3146 );
    }

    Y& r = m_right;
    int r_len = r.length();
    int border = r_len / UL_SIZE;
    if( i < border ) {
 r.set_cword( i, w );
 return;
    }

    X& l = m_left;
    int shift = r_len % UL_SIZE;
    int j = i - border;
    if( shift == 0 ) {
 l.set_cword( j, w );
 return;
    }

    int nshift = UL_SIZE - shift;
    unsigned long lh_mask = ~UL_ZERO << nshift;
    if( i == border ) {
 unsigned long rl_mask = ~UL_ZERO >> nshift;
 r.set_cword( i, w & rl_mask );
 l.set_cword( 0, (l.get_cword( 0 ) & lh_mask) | (w >> shift) );
 return;
    }

    unsigned long ll_mask = ~UL_ZERO >> shift;
    l.set_cword( j - 1, (l.get_cword( j - 1 ) & ll_mask) | (w << nshift) );
    l.set_cword( j, (l.get_cword( j ) & lh_mask) | (w >> shift) );
}




template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref_r<T1,T2> a, sc_subref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref_r<T1,T2> a, sc_bitref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref_r<T1,T2> a, sc_subref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref_r<T1,T2> a, sc_concref_r<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref_r<T1,T2> a, const sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}




template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref_r<T1,T2> a, sc_bitref<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
operator , ( sc_concref<T1,T2> a, sc_bitref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref_r<T1,T2> a, sc_subref<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
operator , ( sc_concref<T1,T2> a, sc_subref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
operator , ( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref<T1,T2> a, const sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
operator , ( sc_concref_r<T1,T2> a, sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref_r<T1,T2> a, sc_bitref<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >
concat( sc_concref<T1,T2> a, sc_bitref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_bitref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref_r<T1,T2> a, sc_subref<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >
concat( sc_concref<T1,T2> a, sc_subref_r<T3> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_subref_r<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref_r<T1,T2> a, sc_concref<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >
concat( sc_concref<T1,T2> a, sc_concref_r<T3,T4> b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_concref_r<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref<T1,T2> a, const sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<sc_concref_r<T1,T2>,T3>
concat( sc_concref_r<T1,T2> a, sc_proxy<T3>& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}
# 3414 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T1, class T2>
inline
void
sc_concref<T1,T2>::scan( istream& is )
{
    sc_string s;
    is >> s;
    *this = s.c_str();
}




template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
operator , ( sc_concref<T1,T2> a, sc_bitref<T3> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
operator , ( sc_concref<T1,T2> a, sc_subref<T3> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
operator , ( sc_concref<T1,T2> a, sc_concref<T3,T4> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,T3>
operator , ( sc_concref<T1,T2> a, sc_proxy<T3>& b )
{
    return sc_concref<sc_concref<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}


template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >
concat( sc_concref<T1,T2> a, sc_bitref<T3> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_bitref<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,sc_subref<T3> >
concat( sc_concref<T1,T2> a, sc_subref<T3> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_subref<T3> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3, class T4>
inline
sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >
concat( sc_concref<T1,T2> a, sc_concref<T3,T4> b )
{
    return sc_concref<sc_concref<T1,T2>,sc_concref<T3,T4> >(
 *a.clone(), *b.clone(), 3 );
}

template <class T1, class T2, class T3>
inline
sc_concref<sc_concref<T1,T2>,T3>
concat( sc_concref<T1,T2> a, sc_proxy<T3>& b )
{
    return sc_concref<sc_concref<T1,T2>,T3>(
 *a.clone(), b.back_cast(), 1 );
}


template <class X, class Y>
inline
istream&
operator >> ( istream& is, sc_concref<X,Y> a )
{
    a.scan( is );
    return is;
}
# 3520 "../../../src/systemc/datatypes/bit/sc_bit_proxies.h"
template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( const sc_proxy<T1>& a, sc_bitref_r<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( const sc_proxy<T1>& a, sc_subref_r<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( const sc_proxy<T1>& a, const sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}


template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( const sc_proxy<T1>& a, sc_bitref_r<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( const sc_proxy<T1>& a, sc_subref_r<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( const sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( const sc_proxy<T1>& a, const sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}




template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( const sc_proxy<T1>& a, sc_bitref<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
operator , ( sc_proxy<T1>& a, sc_bitref_r<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( const sc_proxy<T1>& a, sc_subref<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
operator , ( sc_proxy<T1>& a, sc_subref_r<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( const sc_proxy<T1>& a, sc_concref<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
operator , ( sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( const sc_proxy<T1>& a, sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
operator , ( sc_proxy<T1>& a, const sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}


template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( const sc_proxy<T1>& a, sc_bitref<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_bitref_r<T2> >
concat( sc_proxy<T1>& a, sc_bitref_r<T2> b )
{
    return sc_concref_r<T1,sc_bitref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( const sc_proxy<T1>& a, sc_subref<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,sc_subref_r<T2> >
concat( sc_proxy<T1>& a, sc_subref_r<T2> b )
{
    return sc_concref_r<T1,sc_subref_r<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( const sc_proxy<T1>& a, sc_concref<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref_r<T1,sc_concref_r<T2,T3> >
concat( sc_proxy<T1>& a, sc_concref_r<T2,T3> b )
{
    return sc_concref_r<T1,sc_concref_r<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( const sc_proxy<T1>& a, sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}

template <class T1, class T2>
inline
sc_concref_r<T1,T2>
concat( sc_proxy<T1>& a, const sc_proxy<T2>& b )
{
    return sc_concref_r<T1,T2>(
 a.back_cast(), b.back_cast() );
}






template <class T1, class T2>
inline
sc_concref<T1,sc_bitref<T2> >
operator , ( sc_proxy<T1>& a, sc_bitref<T2> b )
{
    return sc_concref<T1,sc_bitref<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref<T1,sc_subref<T2> >
operator , ( sc_proxy<T1>& a, sc_subref<T2> b )
{
    return sc_concref<T1,sc_subref<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref<T1,sc_concref<T2,T3> >
operator , ( sc_proxy<T1>& a, sc_concref<T2,T3> b )
{
    return sc_concref<T1,sc_concref<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref<T1,T2>
operator , ( sc_proxy<T1>& a, sc_proxy<T2>& b )
{
    return sc_concref<T1,T2>(
 a.back_cast(), b.back_cast() );
}


template <class T1, class T2>
inline
sc_concref<T1,sc_bitref<T2> >
concat( sc_proxy<T1>& a, sc_bitref<T2> b )
{
    return sc_concref<T1,sc_bitref<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref<T1,sc_subref<T2> >
concat( sc_proxy<T1>& a, sc_subref<T2> b )
{
    return sc_concref<T1,sc_subref<T2> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2, class T3>
inline
sc_concref<T1,sc_concref<T2,T3> >
concat( sc_proxy<T1>& a, sc_concref<T2,T3> b )
{
    return sc_concref<T1,sc_concref<T2,T3> >(
 a.back_cast(), *b.clone(), 2 );
}

template <class T1, class T2>
inline
sc_concref<T1,T2>
concat( sc_proxy<T1>& a, sc_proxy<T2>& b )
{
    return sc_concref<T1,T2>(
 a.back_cast(), b.back_cast() );
}

}
# 42 "../../../src/systemc/datatypes/bit/sc_bv_base.h" 2

# 1 "../../../src/systemc/datatypes/int/sc_length_param.h" 1
# 44 "../../../src/systemc/datatypes/bit/sc_bv_base.h" 2


namespace sc_dt
{


class sc_bv_base;
# 59 "../../../src/systemc/datatypes/bit/sc_bv_base.h"
class sc_bv_base
    : public sc_proxy<sc_bv_base>
{
    friend class sc_lv_base;


    void init( int length_, bool init_value = false );

    void assign_from_string( const sc_string& );

public:



    typedef sc_proxy<sc_bv_base> base_type;




    explicit sc_bv_base( int length_ = sc_length_param().len() )
 : m_len( 0 ), m_size( 0 ), m_data( 0 )
 { init( length_ ); }

    explicit sc_bv_base( bool a,
    int length_ = sc_length_param().len() )
 : m_len( 0 ), m_size( 0 ), m_data( 0 )
 { init( length_, a ); }

    sc_bv_base( const char* a );

    sc_bv_base( const char* a, int length_ );

    template <class X>
    sc_bv_base( const sc_proxy<X>& a )
 : m_len( 0 ), m_size( 0 ), m_data( 0 )
 { init( a.back_cast().length() ); base_type::assign_( a ); }

    sc_bv_base( const sc_bv_base& a );
# 121 "../../../src/systemc/datatypes/bit/sc_bv_base.h"
    virtual ~sc_bv_base()
 { if( m_data != 0 ) delete [] m_data; }




    template <class X>
    sc_bv_base& operator = ( const sc_proxy<X>& a )
 { assign_p_( *this, a ); return *this; }

    sc_bv_base& operator = ( const sc_bv_base& a )
 { assign_p_( *this, a ); return *this; }

    sc_bv_base& operator = ( const char* a );

    sc_bv_base& operator = ( const bool* a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( const sc_logic* a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( const sc_unsigned& a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( const sc_signed& a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( const sc_uint_base& a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( const sc_int_base& a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( unsigned long a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( long a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( unsigned int a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( int a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( uint64 a )
 { base_type::assign_( a ); return *this; }

    sc_bv_base& operator = ( int64 a )
 { base_type::assign_( a ); return *this; }
# 213 "../../../src/systemc/datatypes/bit/sc_bv_base.h"
    int length() const
 { return m_len; }

    int size() const
 { return m_size; }

    sc_logic_value_t get_bit( int i ) const;
    void set_bit( int i, sc_logic_value_t value );

    unsigned long get_word( int i ) const
 { return m_data[i]; }

    void set_word( int i, unsigned long w )
 { m_data[i] = w; }

    unsigned long get_cword( int i ) const
 { return UL_ZERO; }

    void set_cword( int i, unsigned long w );

    void clean_tail();




    bool is_01() const
 { return true; }

protected:

    int m_len;
    int m_size;
    unsigned long* m_data;
};
# 279 "../../../src/systemc/datatypes/bit/sc_bv_base.h"
inline
sc_logic_value_t
sc_bv_base::get_bit( int i ) const
{
    int wi = i / UL_SIZE;
    int bi = i % UL_SIZE;
    return sc_logic_value_t( m_data[wi] >> bi & UL_ONE );
}

inline
void
sc_bv_base::set_bit( int i, sc_logic_value_t value )
{
    int wi = i / UL_SIZE;
    int bi = i % UL_SIZE;
    unsigned long mask = UL_ONE << bi;
    m_data[wi] |= mask;
    m_data[wi] &= value << bi | ~mask;
}


inline
void
sc_bv_base::set_cword( int i, unsigned long w )
{
    if( w ) {
 sc_report_handler::report( SC_WARNING, SC_ID_SC_BV_CANNOT_CONTAIN_X_AND_Z_, 0, "../../../src/systemc/datatypes/bit/sc_bv_base.h", 305 );
    }
}


inline
void
sc_bv_base::clean_tail()
{
    int wi = m_size - 1;
    int bi = m_len % UL_SIZE;
 if ( bi != 0 ) m_data[wi] &= ~UL_ZERO >> (UL_SIZE - bi);
}

}
# 45 "../../../src/systemc/datatypes/bit/sc_lv_base.h" 2




namespace sc_dt
{


class sc_lv_base;
# 62 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
class sc_lv_base
    : public sc_proxy<sc_lv_base>
{
    friend class sc_bv_base;


    void init( int length_, const sc_logic& init_value = SC_LOGIC_X );

    void assign_from_string( const sc_string& );

public:



    typedef sc_proxy<sc_lv_base> base_type;




    explicit sc_lv_base( int length_ = sc_length_param().len() )
 : m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
 { init( length_ ); }

    explicit sc_lv_base( const sc_logic& a,
    int length_ = sc_length_param().len() )
 : m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
 { init( length_, a ); }

    sc_lv_base( const char* a );

    sc_lv_base( const char* a, int length_ );

    template <class X>
    sc_lv_base( const sc_proxy<X>& a )
 : m_len( 0 ), m_size( 0 ), m_data( 0 ), m_ctrl( 0 )
 { init( a.back_cast().length() ); base_type::assign_( a ); }

    sc_lv_base( const sc_lv_base& a );
# 124 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
    virtual ~sc_lv_base()
 { if( m_data != 0 ) delete [] m_data; }




    template <class X>
    sc_lv_base& operator = ( const sc_proxy<X>& a )
 { assign_p_( *this, a ); return *this; }

    sc_lv_base& operator = ( const sc_lv_base& a )
 { assign_p_( *this, a ); return *this; }

    sc_lv_base& operator = ( const char* a );

    sc_lv_base& operator = ( const bool* a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( const sc_logic* a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( const sc_unsigned& a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( const sc_signed& a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( const sc_uint_base& a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( const sc_int_base& a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( unsigned long a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( long a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( unsigned int a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( int a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( uint64 a )
 { base_type::assign_( a ); return *this; }

    sc_lv_base& operator = ( int64 a )
 { base_type::assign_( a ); return *this; }
# 221 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
    int length() const
 { return m_len; }

    int size() const
 { return m_size; }

    sc_logic_value_t get_bit( int i ) const;
    void set_bit( int i, sc_logic_value_t value );

    unsigned long get_word( int wi ) const
 { return m_data[wi]; }

    void set_word( int wi, unsigned long w )
 { m_data[wi] = w; }


    unsigned long get_cword( int wi ) const
 { return m_ctrl[wi]; }

    void set_cword( int wi, unsigned long w )
 { m_ctrl[wi] = w; }

    void clean_tail();




    bool is_01() const;

protected:

    int m_len;
    int m_size;
    unsigned long* m_data;
    unsigned long* m_ctrl;
};
# 287 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
inline
sc_logic_value_t
sc_lv_base::get_bit( int i ) const
{
    int wi = i / UL_SIZE;
    int bi = i % UL_SIZE;
    return sc_logic_value_t( m_data[wi] >> bi & UL_ONE |
        m_ctrl[wi] >> bi << 1 & UL_TWO );
}

inline
void
sc_lv_base::set_bit( int i, sc_logic_value_t value )
{
    int wi = i / UL_SIZE;
    int bi = i % UL_SIZE;
    unsigned long mask = UL_ONE << bi;
    m_data[wi] |= mask;
    m_ctrl[wi] |= mask;
    m_data[wi] &= value << bi | ~mask;
    m_ctrl[wi] &= value >> 1 << bi | ~mask;
}


inline
void
sc_lv_base::clean_tail()
{
    int wi = m_size - 1;
    int bi = m_len % UL_SIZE;
    unsigned long mask = ~UL_ZERO >> (UL_SIZE - bi);
 if ( mask )
 {
  m_data[wi] &= mask;
  m_ctrl[wi] &= mask;
 }
}
# 337 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X>
inline
const sc_lv_base
sc_proxy<X>::operator ~ () const
{
    sc_lv_base a( back_cast() );
    return a.b_not();
}




template <class X, class Y>
inline
X&
operator &= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_and_assign_( x, a );
}
# 373 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline X& sc_proxy<X>::operator &= ( const char* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( const bool* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( const sc_logic* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( const sc_unsigned& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( const sc_signed& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( unsigned long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( uint64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator &= ( int64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_and_assign_( x, a ); }




template <class X, class Y>
inline
const sc_lv_base
operator & ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    sc_lv_base a( px.back_cast() );
    return ( a &= py.back_cast() );
}
# 406 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const char* b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const bool* b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const sc_logic* b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const sc_unsigned& b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const sc_signed& b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const sc_uint_base& b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( const sc_int_base& b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( unsigned long b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( long b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( unsigned int b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( int b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( uint64 b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator & ( int64 b ) const { sc_lv_base a( back_cast() ); return ( a &= b ); }
# 432 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base operator & ( const char* b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const bool* b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const sc_logic* b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const sc_unsigned& b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const sc_signed& b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const sc_uint_base& b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( const sc_int_base& b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( unsigned long b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( long b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( unsigned int b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( int b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( uint64 b, const sc_proxy<X>& px ) { return ( px & b ); }
template <class X> inline const sc_lv_base operator & ( int64 b, const sc_proxy<X>& px ) { return ( px & b ); }






template <class X, class Y>
inline
X&
operator |= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_or_assign_( x, a );
}
# 475 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline X& sc_proxy<X>::operator |= ( const char* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( const bool* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( const sc_logic* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( const sc_unsigned& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( const sc_signed& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( unsigned long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( uint64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator |= ( int64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_or_assign_( x, a ); }




template <class X, class Y>
inline
const sc_lv_base
operator | ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    sc_lv_base a( px.back_cast() );
    return ( a |= py.back_cast() );
}
# 508 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const char* b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const bool* b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const sc_logic* b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const sc_unsigned& b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const sc_signed& b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const sc_uint_base& b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( const sc_int_base& b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( unsigned long b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( long b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( unsigned int b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( int b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( uint64 b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator | ( int64 b ) const { sc_lv_base a( back_cast() ); return ( a |= b ); }
# 534 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base operator | ( const char* b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const bool* b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const sc_logic* b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const sc_unsigned& b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const sc_signed& b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const sc_uint_base& b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( const sc_int_base& b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( unsigned long b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( long b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( unsigned int b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( int b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( uint64 b, const sc_proxy<X>& px ) { return ( px | b ); }
template <class X> inline const sc_lv_base operator | ( int64 b, const sc_proxy<X>& px ) { return ( px | b ); }






template <class X, class Y>
inline
X&
operator ^= ( sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    X& x = px.back_cast();
    sc_lv_base a( x.length() );
    a = py.back_cast();
    return b_xor_assign_( x, a );
}
# 577 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline X& sc_proxy<X>::operator ^= ( const char* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( const bool* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( const sc_logic* b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( const sc_unsigned& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( const sc_signed& b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( unsigned long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( long b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( uint64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }
template <class X> inline X& sc_proxy<X>::operator ^= ( int64 b ) { X& x = back_cast(); sc_lv_base a( x.length() ); a = b; return b_xor_assign_( x, a ); }




template <class X, class Y>
inline
const sc_lv_base
operator ^ ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    sc_lv_base a( px.back_cast() );
    return ( a ^= py.back_cast() );
}
# 610 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const char* b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const bool* b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const sc_logic* b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const sc_unsigned& b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const sc_signed& b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const sc_uint_base& b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( const sc_int_base& b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( unsigned long b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( long b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( unsigned int b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( int b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( uint64 b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
template <class X> inline const sc_lv_base sc_proxy<X>::operator ^ ( int64 b ) const { sc_lv_base a( back_cast() ); return ( a ^= b ); }
# 636 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline const sc_lv_base operator ^ ( const char* b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const bool* b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const sc_logic* b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const sc_unsigned& b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const sc_signed& b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const sc_uint_base& b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( const sc_int_base& b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( unsigned long b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( long b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( unsigned int b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( int b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( uint64 b, const sc_proxy<X>& px ) { return ( px ^ b ); }
template <class X> inline const sc_lv_base operator ^ ( int64 b, const sc_proxy<X>& px ) { return ( px ^ b ); }






template <class X>
inline
const sc_lv_base
sc_proxy<X>::operator << ( int n ) const
{
    sc_lv_base a( back_cast() );
    return ( a <<= n );
}




template <class X>
inline
const sc_lv_base
sc_proxy<X>::operator >> ( int n ) const
{
    sc_lv_base a( back_cast() );
    return ( a >>= n );
}




template <class X>
inline
X&
sc_proxy<X>::lrotate( int n )
{
    X& x = back_cast();
    if( n < 0 ) {
 char msg[8192];
 sprintf( msg,
   "left rotate operation is only allowed with positive "
   "rotate values, rotate value = %d", n );
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, msg, "../../../src/systemc/datatypes/bit/sc_lv_base.h", 690 );
    }
    int len = x.length();
    n %= len;

    sc_lv_base a( x << n );
    sc_lv_base b( x >> (len - n) );
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 x.set_word( i, a.get_word( i ) | b.get_word( i ) );
 x.set_cword( i, a.get_cword( i ) | b.get_cword( i ) );
    }
    x.clean_tail();
    return x;
}

template <class X>
inline
const sc_lv_base
lrotate( const sc_proxy<X>& x, int n )
{
    sc_lv_base a( x.back_cast() );
    return a.lrotate( n );
}




template <class X>
inline
X&
sc_proxy<X>::rrotate( int n )
{
    X& x = back_cast();
    if( n < 0 ) {
 char msg[8192];
 sprintf( msg,
   "right rotate operation is only allowed with positive "
   "rotate values, rotate value = %d", n );
 sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_BOUNDS_, msg, "../../../src/systemc/datatypes/bit/sc_lv_base.h", 729 );
    }
    int len = x.length();
    n %= len;

    sc_lv_base a( x >> n );
    sc_lv_base b( x << (len - n) );
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 x.set_word( i, a.get_word( i ) | b.get_word( i ) );
 x.set_cword( i, a.get_cword( i ) | b.get_cword( i ) );
    }
    x.clean_tail();
    return x;
}

template <class X>
inline
const sc_lv_base
rrotate( const sc_proxy<X>& x, int n )
{
    sc_lv_base a( x.back_cast() );
    return a.rrotate( n );
}




template <class X>
inline
const sc_lv_base
reverse( const sc_proxy<X>& x )
{
    sc_lv_base a( x.back_cast() );
    return a.reverse();
}




template <class X, class Y>
inline
bool
operator == ( const sc_proxy<X>& px, const sc_proxy<Y>& py )
{
    const X& x = px.back_cast();
    const Y& y = py.back_cast();
    int x_len = x.length();
    int y_len = y.length();
    if( x_len != y_len ) {
 return false;
    }
    int sz = x.size();
    for( int i = 0; i < sz; ++ i ) {
 if( x.get_word( i ) != y.get_word( i ) ||
     x.get_cword( i ) != y.get_cword( i ) ) {
     return false;
 }
    }
    return true;
}
# 804 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X> inline bool sc_proxy<X>::operator == ( const char* b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const bool* b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const sc_logic* b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const sc_unsigned& b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const sc_signed& b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const sc_uint_base& b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( const sc_int_base& b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( unsigned long b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( long b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( unsigned int b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( int b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( uint64 b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
template <class X> inline bool sc_proxy<X>::operator == ( int64 b ) const { const X& x = back_cast(); sc_lv_base y( x.length() ); y = b; return ( x == y ); }
# 829 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T> a, const char* b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const char* a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const sc_logic& a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref_r<T> a, bool b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( bool a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T> a, const char* b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const char* a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const sc_logic& a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref_r<T> a, bool b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( bool a, sc_bitref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}




template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T> a, const char* b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const char* a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( const sc_logic& a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
operator , ( sc_bitref<T> a, bool b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
operator , ( bool a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T> a, const char* b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const char* a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( const sc_logic& a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_bitref_r<T>,sc_lv_base>
concat( sc_bitref<T> a, bool b )
{
    return sc_concref_r<sc_bitref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ) );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_bitref_r<T> >
concat( bool a, sc_bitref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_bitref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}
# 1061 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T> a, const char* b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const char* a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const sc_logic& a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref_r<T> a, bool b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( bool a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T> a, const char* b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const char* a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const sc_logic& a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref_r<T> a, bool b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( bool a, sc_subref_r<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}




template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T> a, const char* b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const char* a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( const sc_logic& a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
operator , ( sc_subref<T> a, bool b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
operator , ( bool a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T> a, const char* b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const char* a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T> a, const sc_logic& b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( const sc_logic& a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T>
inline
sc_concref_r<sc_subref_r<T>,sc_lv_base>
concat( sc_subref<T> a, bool b )
{
    return sc_concref_r<sc_subref_r<T>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,sc_subref_r<T> >
concat( bool a, sc_subref<T> b )
{
    return sc_concref_r<sc_lv_base,sc_subref_r<T> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}
# 1291 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class X>
inline
sc_subref<X>&
sc_subref<X>::operator = ( const sc_subref_r<X>& b )
{
    sc_lv_base t( b );
    int len = sc_min( this->length(), t.length() );
    if( ! this->reversed() ) {
        for( int i = len - 1; i >= 0; -- i ) {
            this->m_obj.set_bit( this->m_lo + i, t[i].value() );
        }
    } else {
        for( int i = len - 1; i >= 0; -- i ) {
            this->m_obj.set_bit( this->m_lo - i, t[i].value() );
        }
    }
    return *this;
}

template <class X>
inline
sc_subref<X>&
sc_subref<X>::operator = ( const sc_subref<X>& b )
{
    sc_lv_base t( b );
    int len = sc_min( this->length(), t.length() );
    if( ! this->reversed() ) {
        for( int i = len - 1; i >= 0; -- i ) {
            this->m_obj.set_bit( this->m_lo + i, t[i].value() );
        }
    } else {
        for( int i = len - 1; i >= 0; -- i ) {
            this->m_obj.set_bit( this->m_lo - i, t[i].value() );
        }
    }
    return *this;
}
# 1338 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2> a, const char* b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const char* a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2> a, const sc_logic& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const sc_logic& a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref_r<T1,T2> a, bool b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( bool a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2> a, const char* b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const char* a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2> a, const sc_logic& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const sc_logic& a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref_r<T1,T2> a, bool b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( bool a, sc_concref_r<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}




template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2> a, const char* b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const char* a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2> a, const sc_logic& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( const sc_logic& a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
operator , ( sc_concref<T1,T2> a, bool b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
operator , ( bool a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}


template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2> a, const char* b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const char* a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2> a, const sc_logic& b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( b, 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( const sc_logic& a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( a, 1 ), *b.clone(), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>
concat( sc_concref<T1,T2> a, bool b )
{
    return sc_concref_r<sc_concref_r<T1,T2>,sc_lv_base>(
 *a.clone(), *new sc_lv_base( sc_logic( b ), 1 ), 3 );
}

template <class T1, class T2>
inline
sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >
concat( bool a, sc_concref<T1,T2> b )
{
    return sc_concref_r<sc_lv_base,sc_concref_r<T1,T2> >(
 *new sc_lv_base( sc_logic( a ), 1 ), *b.clone(), 3 );
}
# 1571 "../../../src/systemc/datatypes/bit/sc_lv_base.h"
template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>& a, const char* b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const char* a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>& a, const sc_logic& b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const sc_logic& a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( const sc_proxy<T>& a, bool b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( bool a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}


template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>& a, const char* b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const char* a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>& a, const sc_logic& b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const sc_logic& a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( const sc_proxy<T>& a, bool b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( bool a, const sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}




template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>& a, const char* b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const char* a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>& a, const sc_logic& b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( const sc_logic& a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
operator , ( sc_proxy<T>& a, bool b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
operator , ( bool a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}


template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>& a, const char* b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const char* a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>& a, const sc_logic& b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( b, 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( const sc_logic& a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( a, 1 ), b.back_cast(), 1 );
}

template <class T>
inline
sc_concref_r<T,sc_lv_base>
concat( sc_proxy<T>& a, bool b )
{
    return sc_concref_r<T,sc_lv_base>(
 a.back_cast(), *new sc_lv_base( sc_logic( b ), 1 ), 2 );
}

template <class T>
inline
sc_concref_r<sc_lv_base,T>
concat( bool a, sc_proxy<T>& b )
{
    return sc_concref_r<sc_lv_base,T>(
 *new sc_lv_base( sc_logic( a ), 1 ), b.back_cast(), 1 );
}



}
# 71 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/int/sc_signed.h" 1
# 72 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/int/sc_unsigned.h" 1
# 73 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/int/sc_int_base.h" 1
# 74 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/int/sc_uint_base.h" 1
# 75 "sc_wif_trace.cpp" 2
# 1 "../../../src/systemc/datatypes/fx/fx.h" 1
# 40 "../../../src/systemc/datatypes/fx/fx.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fixed.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fixed.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fix.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fix.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fxnum.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
# 1 "../../../src/systemc/datatypes/bit/sc_lv_base.h" 1
# 41 "../../../src/systemc/datatypes/fx/sc_fxnum.h" 2
# 1 "../../../src/systemc/datatypes/fx/sc_fxval.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fxval.h"
# 1 "../../../src/systemc/datatypes/fx/scfx_rep.h" 1
# 41 "../../../src/systemc/datatypes/fx/scfx_rep.h"
# 1 "/usr/lib/gcc/i386-redhat-linux/3.4.2/include/limits.h" 1 3 4
# 42 "../../../src/systemc/datatypes/fx/scfx_rep.h" 2

# 1 "../../../src/systemc/datatypes/fx/scfx_mant.h" 1
# 41 "../../../src/systemc/datatypes/fx/scfx_mant.h"
# 1 "../../../src/systemc/datatypes/fx/scfx_ieee.h" 1
# 42 "../../../src/systemc/datatypes/fx/scfx_mant.h" 2
# 1 "../../../src/systemc/datatypes/fx/scfx_utils.h" 1
# 41 "../../../src/systemc/datatypes/fx/scfx_utils.h"
# 1 "../../../src/systemc/datatypes/fx/scfx_params.h" 1
# 41 "../../../src/systemc/datatypes/fx/scfx_params.h"
# 1 "../../../src/systemc/datatypes/fx/sc_fxcast_switch.h" 1
# 40 "../../../src/systemc/datatypes/fx/sc_fxcast_switch.h"
# 1 "../../../src/systemc/datatypes/fx/sc_context.h" 1
# 41 "../../../src/systemc/datatypes/fx/sc_fxcast_switch.h" 2


namespace sc_dt
{


class sc_fxcast_switch;
# 56 "../../../src/systemc/datatypes/fx/sc_fxcast_switch.h"
class sc_fxcast_switch
{

public:

             sc_fxcast_switch();
             sc_fxcast_switch( sc_switch );
             sc_fxcast_switch( const sc_fxcast_switch& );
    explicit sc_fxcast_switch( sc_without_context );

    sc_fxcast_switch& operator = ( const sc_fxcast_switch& );

    friend bool operator == ( const sc_fxcast_switch&,
         const sc_fxcast_switch& );
    friend bool operator != ( const sc_fxcast_switch&,
         const sc_fxcast_switch& );

    const sc_string to_string() const;

    void print( ostream& = cout ) const;
    void dump( ostream& = cout ) const;

private:

    sc_switch m_sw;

};
# 91 "../../../src/systemc/datatypes/fx/sc_fxcast_switch.h"
typedef sc_context<sc_fxcast_switch> sc_fxcast_context;




inline
sc_fxcast_switch::sc_fxcast_switch()
{
    *this = sc_fxcast_context::default_value();
}

inline
sc_fxcast_switch::sc_fxcast_switch( sc_switch sw_ )
: m_sw( sw_ )
{}

inline
sc_fxcast_switch::sc_fxcast_switch( const sc_fxcast_switch& a )
: m_sw( a.m_sw )
{}

inline
sc_fxcast_switch::sc_fxcast_switch( sc_without_context )
: m_sw( SC_DEFAULT_CAST_SWITCH_ )
{}


inline
sc_fxcast_switch&
sc_fxcast_switch::operator = ( const sc_fxcast_switch& a )
{
    if( &a != this )
    {
        m_sw = a.m_sw;
    }
    return *this;
}


inline
bool
operator == ( const sc_fxcast_switch& a, const sc_fxcast_switch& b )
{
    return ( a.m_sw == b.m_sw );
}


inline
bool
operator != ( const sc_fxcast_switch& a, const sc_fxcast_switch& b )
{
    return ( a.m_sw != b.m_sw );
}


inline
ostream&
operator << ( ostream& os, const sc_fxcast_switch& a )
{
    a.print( os );
    return os;
}

}
# 42 "../../../src/systemc/datatypes/fx/scfx_params.h" 2
# 1 "../../../src/systemc/datatypes/fx/sc_fxtype_params.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_fxtype_params.h"
namespace sc_dt
{


class sc_fxtype_params;
# 56 "../../../src/systemc/datatypes/fx/sc_fxtype_params.h"
class sc_fxtype_params
{
public:

             sc_fxtype_params();
             sc_fxtype_params( int, int );
             sc_fxtype_params( sc_q_mode, sc_o_mode, int = 0 );
             sc_fxtype_params( int, int, sc_q_mode, sc_o_mode, int = 0 );
             sc_fxtype_params( const sc_fxtype_params& );
      sc_fxtype_params( const sc_fxtype_params&,
          int, int );
      sc_fxtype_params( const sc_fxtype_params&,
                    sc_q_mode, sc_o_mode, int = 0 );
    explicit sc_fxtype_params( sc_without_context );

    sc_fxtype_params& operator = ( const sc_fxtype_params& );

    friend bool operator == ( const sc_fxtype_params&,
                              const sc_fxtype_params& );
    friend bool operator != ( const sc_fxtype_params&,
         const sc_fxtype_params& );

    int wl() const;
    void wl( int );

    int iwl() const;
    void iwl( int );

    sc_q_mode q_mode() const;
    void q_mode( sc_q_mode );

    sc_o_mode o_mode() const;
    void o_mode( sc_o_mode );

    int n_bits() const;
    void n_bits( int );

    const sc_string to_string() const;

    void print( ostream& = cout ) const;
    void dump( ostream& = cout ) const;

private:

    int m_wl;
    int m_iwl;
    sc_q_mode m_q_mode;
    sc_o_mode m_o_mode;
    int m_n_bits;
};
# 114 "../../../src/systemc/datatypes/fx/sc_fxtype_params.h"
typedef sc_context<sc_fxtype_params> sc_fxtype_context;




inline
sc_fxtype_params::sc_fxtype_params()
{
    *this = sc_fxtype_context::default_value();
}

inline
sc_fxtype_params::sc_fxtype_params( int wl_, int iwl_ )
{
    *this = sc_fxtype_context::default_value();

    { if( (wl_) <= 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_WL_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 130 ); };
    m_wl = wl_;
    m_iwl = iwl_;
}

inline
sc_fxtype_params::sc_fxtype_params( sc_q_mode q_mode_,
                                    sc_o_mode o_mode_, int n_bits_ )
{
    *this = sc_fxtype_context::default_value();

    { if( (n_bits_) < 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_N_BITS_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 141 ); };
    m_q_mode = q_mode_;
    m_o_mode = o_mode_;
    m_n_bits = n_bits_;
}

inline
sc_fxtype_params::sc_fxtype_params( int wl_, int iwl_,
                                    sc_q_mode q_mode_,
                                    sc_o_mode o_mode_, int n_bits_ )
{
    { if( (wl_) <= 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_WL_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 152 ); };
    { if( (n_bits_) < 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_N_BITS_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 153 ); };
    m_wl = wl_;
    m_iwl = iwl_;
    m_q_mode = q_mode_;
    m_o_mode = o_mode_;
    m_n_bits = n_bits_;
}

inline
sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a )
: m_wl( a.m_wl ), m_iwl( a.m_iwl ),
  m_q_mode( a.m_q_mode ),
  m_o_mode( a.m_o_mode ), m_n_bits( a.m_n_bits )
{}

inline
sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a,
        int wl_, int iwl_ )
: m_wl( wl_ ), m_iwl( iwl_ ),
  m_q_mode( a.m_q_mode ),
  m_o_mode( a.m_o_mode ), m_n_bits( a.m_n_bits )
{}

inline
sc_fxtype_params::sc_fxtype_params( const sc_fxtype_params& a,
        sc_q_mode q_mode_,
        sc_o_mode o_mode_, int n_bits_ )
: m_wl( a.m_wl ), m_iwl( a.m_iwl ),
  m_q_mode( q_mode_ ),
  m_o_mode( o_mode_ ), m_n_bits( n_bits_ )
{}

inline
sc_fxtype_params::sc_fxtype_params( sc_without_context )
: m_wl ( SC_DEFAULT_WL_ ),
  m_iwl ( SC_DEFAULT_IWL_ ),
  m_q_mode( SC_DEFAULT_Q_MODE_ ),
  m_o_mode( SC_DEFAULT_O_MODE_ ),
  m_n_bits( SC_DEFAULT_N_BITS_ )
{}


inline
sc_fxtype_params&
sc_fxtype_params::operator = ( const sc_fxtype_params& a )
{
    if( &a != this )
    {
        m_wl = a.m_wl;
 m_iwl = a.m_iwl;
 m_q_mode = a.m_q_mode;
 m_o_mode = a.m_o_mode;
 m_n_bits = a.m_n_bits;
    }
    return *this;
}


inline
bool
operator == ( const sc_fxtype_params& a, const sc_fxtype_params& b )
{
    return ( a.m_wl == b.m_wl &&
      a.m_iwl == b.m_iwl &&
      a.m_q_mode == b.m_q_mode &&
      a.m_o_mode == b.m_o_mode &&
      a.m_n_bits == b.m_n_bits );
}

inline
bool
operator != ( const sc_fxtype_params& a, const sc_fxtype_params& b )
{
    return ( a.m_wl != b.m_wl ||
      a.m_iwl != b.m_iwl ||
      a.m_q_mode != b.m_q_mode ||
      a.m_o_mode != b.m_o_mode ||
      a.m_n_bits != b.m_n_bits );
}


inline
int
sc_fxtype_params::wl() const
{
    return m_wl;
}

inline
void
sc_fxtype_params::wl( int wl_ )
{
    { if( (wl_) <= 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_WL_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 245 ); };
    m_wl = wl_;
}


inline
int
sc_fxtype_params::iwl() const
{
    return m_iwl;
}

inline
void
sc_fxtype_params::iwl( int iwl_ )
{
    m_iwl = iwl_;
}


inline
sc_q_mode
sc_fxtype_params::q_mode() const
{
    return m_q_mode;
}

inline
void
sc_fxtype_params::q_mode( sc_q_mode q_mode_ )
{
    m_q_mode = q_mode_;
}


inline
sc_o_mode
sc_fxtype_params::o_mode() const
{
    return m_o_mode;
}

inline
void
sc_fxtype_params::o_mode( sc_o_mode o_mode_ )
{
    m_o_mode = o_mode_;
}


inline
int
sc_fxtype_params::n_bits() const
{
    return m_n_bits;
}

inline
void
sc_fxtype_params::n_bits( int n_bits_ )
{
    { if( (n_bits_) < 0 ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_N_BITS_, 0, "../../../src/systemc/datatypes/fx/sc_fxtype_params.h", 306 ); };
    m_n_bits = n_bits_;
}


inline
ostream&
operator << ( ostream& os, const sc_fxtype_params& a )
{
    a.print( os );
    return os;
}

}
# 43 "../../../src/systemc/datatypes/fx/scfx_params.h" 2


namespace sc_dt
{


class scfx_params;
# 58 "../../../src/systemc/datatypes/fx/scfx_params.h"
class scfx_params
{

public:



    scfx_params( const sc_fxtype_params&,
   sc_enc,
   const sc_fxcast_switch& );




    const sc_fxtype_params& type_params() const;
    sc_enc enc() const;
    const sc_fxcast_switch& cast_switch() const;




    int wl() const;
    int iwl() const;
    int fwl() const;
    sc_q_mode q_mode() const;
    sc_o_mode o_mode() const;
    int n_bits() const;




    void dump( ostream& ) const;

private:

    sc_fxtype_params m_type_params;
    sc_enc m_enc;
    sc_fxcast_switch m_cast_switch;

};






inline
scfx_params::scfx_params( const sc_fxtype_params& type_params_,
     sc_enc enc_,
     const sc_fxcast_switch& cast_sw )
: m_type_params( type_params_ ),
  m_enc( enc_ ),
  m_cast_switch( cast_sw )
{
    if( m_enc == SC_US_ && m_type_params.o_mode() == SC_WRAP_SM )
    {
 sc_report_handler::report( SC_ERROR, SC_ID_INVALID_O_MODE_, "SC_WRAP_SM not defined for unsigned numbers", "../../../src/systemc/datatypes/fx/scfx_params.h", 115 );

    }

}




inline
const sc_fxtype_params&
scfx_params::type_params() const
{
    return m_type_params;
}

inline
sc_enc
scfx_params::enc() const
{
    return m_enc;
}

inline
const sc_fxcast_switch&
scfx_params::cast_switch() const
{
    return m_cast_switch;
}




inline
int
scfx_params::wl() const
{
    return m_type_params.wl();
}

inline
int
scfx_params::iwl() const
{
    return m_type_params.iwl();
}

inline
int
scfx_params::fwl() const
{
    return ( m_type_params.wl() - m_type_params.iwl() );
}

inline
sc_q_mode
scfx_params::q_mode() const
{
    return m_type_params.q_mode();
}

inline
sc_o_mode
scfx_params::o_mode() const
{
    return m_type_params.o_mode();
}

inline
int
scfx_params::n_bits() const
{
    return m_type_params.n_bits();
}




inline
void
scfx_params::dump( ostream& os ) const
{
    os << "scfx_params" << endl;
    os << "(" << endl;
    os << "type_params = ";
    m_type_params.dump( os );
    os << "enc         = " << m_enc << endl;
    os << "cast_switch = ";
    m_cast_switch.dump( os );
    os << ")" << endl;
}

}
# 42 "../../../src/systemc/datatypes/fx/scfx_utils.h" 2
# 1 "../../../src/systemc/datatypes/fx/scfx_string.h" 1
# 43 "../../../src/systemc/datatypes/fx/scfx_string.h"
namespace sc_dt
{


class scfx_string;
# 56 "../../../src/systemc/datatypes/fx/scfx_string.h"
class scfx_string
{
    void resize( size_t );

public:

    scfx_string();

    ~scfx_string();

    int length() const;

    void clear();

    char& operator [] ( int );

    void append( int );
    void discard( int );
    void remove( int );

    void operator += ( char );
    void operator += ( const char* );

    operator const char* ();

private:

    size_t m_len;
    size_t m_alloc;
    char* m_buffer;
};




inline
void
scfx_string::resize( size_t i )
{
    do {
 m_alloc *= 2;
    } while( i >= m_alloc );

    char* temp = new char[m_alloc];

    for( int j = 0; j < (int) m_len; ++ j ) {
 temp[j] = m_buffer[j];
    }
    temp[m_len] = 0;

    delete [] m_buffer;
    m_buffer = temp;
}


inline
scfx_string::scfx_string()
: m_len( 0 ), m_alloc( 8192 ), m_buffer( new char[m_alloc] )
{
    m_buffer[m_len] = 0;
}


inline
scfx_string::~scfx_string()
{
    delete [] m_buffer;
}


inline
int
scfx_string::length() const
{
    return m_len;
}


inline
void
scfx_string::clear()
{
    m_len = 0;
    m_buffer[m_len] = 0;
}


inline
char&
scfx_string::operator [] ( int i )
{
    if( i >= (int) m_alloc ) {
 resize( i );
    }
    return m_buffer[i];
}


inline
void
scfx_string::append( int n )
{
    m_len += n;
    m_buffer[m_len] = 0;
}

inline
void
scfx_string::discard( int n )
{
    m_len -= n;
    m_buffer[m_len] = 0;
}

inline
void
scfx_string::remove( int i )
{
    for( int j = i + 1; j < (int) m_len; ++ j )
 m_buffer[j - 1] = m_buffer[j];
    -- m_len;
    m_buffer[m_len] = 0;
}


inline
void
scfx_string::operator += ( char c )
{
    this->operator [] ( m_len ) = c;
    m_len ++;
    m_buffer[m_len] = 0;
}

inline
void
scfx_string::operator += ( const char* s )
{
    while( *s )
 (*this) += *s ++;
}


inline
scfx_string::operator const char*()
{
    m_buffer[m_len] = 0;
    return m_buffer;
}

}
# 43 "../../../src/systemc/datatypes/fx/scfx_utils.h" 2


namespace sc_dt
{







inline
int
scfx_find_msb( unsigned long x )
{
    int i = 0;
    if( x >> 16 ) { x >>= 16; i += 16; };
    if( x >> 8 ) { x >>= 8; i += 8; };
    if( x >> 4 ) { x >>= 4; i += 4; };
    if( x >> 2 ) { x >>= 2; i += 2; };
    if( x >> 1 ) { x >>= 1; i += 1; };
    return i;
}





inline
int
scfx_find_lsb( unsigned long x )
{
    int i = 31;
    if( x << 16 ) { x <<= 16; i -= 16; };
    if( x << 8 ) { x <<= 8; i -= 8; };
    if( x << 4 ) { x <<= 4; i -= 4; };
    if( x << 2 ) { x <<= 2; i -= 2; };
    if( x << 1 ) { x <<= 1; i -= 1; };
    return i;
}
# 91 "../../../src/systemc/datatypes/fx/scfx_utils.h"
inline
int
scfx_parse_sign( const char*& s, bool& sign_char )
{
    int sign = 1;

    if( *s == '+' )
    {
        ++ s;
 sign_char = true;
    }
    else if( *s == '-' )
    {
        sign = -1;
        ++ s;
 sign_char = true;
    }
    else
 sign_char = false;

    return sign;
}

inline
sc_numrep
scfx_parse_prefix( const char*& s )
{
    if( s[0] == '0' ) {
 switch( s[1] ) {
 case 'b':
 case 'B':
 {
     if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
  s += 4;
  return SC_BIN_US;
     }
     if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
  s += 4;
  return SC_BIN_SM;
     }
     s += 2;
     return SC_BIN;
 }
 case 'o':
 case 'O':
 {
     if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
  s += 4;
  return SC_OCT_US;
     }
     if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
  s += 4;
  return SC_OCT_SM;
     }
     s += 2;
     return SC_OCT;
 }
 case 'x':
 case 'X':
 {
     if( s[2] == 'u' || s[2] == 'U' && s[3] == 's' || s[3] == 'S' ) {
  s += 4;
  return SC_HEX_US;
     }
     if( s[2] == 's' || s[2] == 'S' && s[3] == 'm' || s[3] == 'M' ) {
  s += 4;
  return SC_HEX_SM;
     }
     s += 2;
     return SC_HEX;
 }
 case 'd':
 case 'D':
 {
     s += 2;
     return SC_DEC;
 }
 case 'c':
 case 'C':
 {
     if( s[2] == 's' || s[2] == 'S' && s[3] == 'd' || s[3] == 'D' ) {
  s += 4;
  return SC_CSD;
     }
     break;
 }
 default:
     break;
 }
    }

    return SC_DEC;
}


inline
int
scfx_parse_base( const char*& s )
{
    const char* s1 = s + 1;

    int base = 10;

    if( *s == '0' )
    {
        switch( *s1 )
 {
            case 'b':
            case 'B': base = 2; s += 2; break;
            case 'o':
            case 'O': base = 8; s += 2; break;
            case 'd':
            case 'D': base = 10; s += 2; break;
            case 'x':
            case 'X': base = 16; s += 2; break;
        }
    }

    return base;
}

inline
bool
scfx_is_equal( const char* a, const char* b )
{
    while( *a != 0 && *b != 0 && *a == *b )
    {
        ++ a;
        ++ b;
    }
    return ( *a == 0 && *b == 0 );
}

inline
bool
scfx_is_nan( const char* s )
{
    return scfx_is_equal( s, "NaN" );
}

inline
bool
scfx_is_inf( const char* s )
{
    return ( scfx_is_equal( s, "Inf" ) || scfx_is_equal( s, "Infinity" ) );
}

inline
bool
scfx_exp_start( const char* s )
{
    if( *s == 'e' || *s == 'E' )
    {
        ++ s;
        if( *s == '+' || *s == '-' )
            return true;
    }
    return false;
}

inline
bool
scfx_is_digit( char c, sc_numrep numrep )
{
    bool is_digit;

    switch( numrep )
    {
        case SC_DEC:
 {
            switch( c )
     {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
  {
                    is_digit = true;
                    break;
  }
                default:
                    is_digit = false;
            }
            break;
 }
 case SC_BIN:
 case SC_BIN_US:
 case SC_BIN_SM:
 {
            switch( c )
     {
                case '0': case '1':
  {
                    is_digit = true;
                    break;
  }
                default:
                    is_digit = false;
            }
            break;
 }
 case SC_OCT:
 case SC_OCT_US:
 case SC_OCT_SM:
 {
            switch( c )
     {
                case '0': case '1': case '2': case '3':
                case '4': case '5': case '6': case '7':
  {
                    is_digit = true;
                    break;
  }
                default:
                    is_digit = false;
            }
            break;
 }
 case SC_HEX:
 case SC_HEX_US:
 case SC_HEX_SM:
 {
            switch( c )
     {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  {
                    is_digit = true;
                    break;
  }
                default:
                    is_digit = false;
            }
            break;
 }
 case SC_CSD:
 {
            switch( c )
     {
  case '0': case '1': case '-':
  {
                    is_digit = true;
                    break;
  }
                default:
                    is_digit = false;
            }
            break;
 }
 default:
            is_digit = false;
    }

    return is_digit;
}

inline
int
scfx_to_digit( char c, sc_numrep numrep )
{
    int to_digit;

    switch( numrep )
    {
 case SC_DEC:
 case SC_BIN:
 case SC_BIN_US:
 case SC_BIN_SM:
 case SC_OCT:
 case SC_OCT_US:
 case SC_OCT_SM:
 {
            to_digit = c - '0';
            break;
 }
 case SC_HEX:
 case SC_HEX_US:
 case SC_HEX_SM:
 {
            switch( c )
     {
                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                    to_digit = c - '0';
                    break;
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                    to_digit = c - 'a' + 10;
                    break;
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    to_digit = c - 'A' + 10;
                    break;
                default:
                    to_digit = -2;
            }
            break;
 }
 case SC_CSD:
 {
     if( c == '-' )
  to_digit = -1;
     else
  to_digit = c - '0';
 }
 default:
     to_digit = -2;
    };

    return to_digit;
}






inline
void
scfx_print_nan( scfx_string& s )
{
    s += "NaN";
}

inline
void
scfx_print_inf( scfx_string& s, bool negative )
{
    if( negative )
        s += "-Inf";
    else
        s += "Inf";
}

inline
void
scfx_print_prefix( scfx_string& s, sc_numrep numrep )
{
    switch( numrep )
    {
        case SC_DEC:
     s += "0d";
     break;
        case SC_BIN:
     s += "0b";
     break;
        case SC_BIN_US:
     s += "0bus";
     break;
        case SC_BIN_SM:
     s += "0bsm";
     break;
        case SC_OCT:
     s += "0o";
     break;
        case SC_OCT_US:
     s += "0ous";
     break;
        case SC_OCT_SM:
     s += "0osm";
     break;
        case SC_HEX:
     s += "0x";
     break;
        case SC_HEX_US:
     s += "0xus";
     break;
        case SC_HEX_SM:
     s += "0xsm";
     break;
        case SC_CSD:
     s += "0csd";
     break;
        default:
     s += "unknown";
    }
}

inline
void
scfx_print_exp( scfx_string& s, int exp )
{
    if( exp != 0 )
    {
        s += 'e';

        if( exp < 0 )
 {
            exp = - exp;
            s += '-';
        }
 else
            s += '+';

        bool first = true;
        int scale = 1000000000;
        do
 {
            int digit = exp / scale;
            exp = exp % scale;
            if( digit != 0 || ! first )
     {
                s += static_cast<char>( digit + '0' );
                first = false;
            }
            scale /= 10;
        }
 while( scale > 0 );
    }
}


void scfx_tc2csd( scfx_string&, int );
void scfx_csd2tc( scfx_string& );

}
# 43 "../../../src/systemc/datatypes/fx/scfx_mant.h" 2
# 1 "../../../src/systemc/kernel/sc_macros.h" 1
# 44 "../../../src/systemc/datatypes/fx/scfx_mant.h" 2


namespace sc_dt
{


class scfx_mant;
class scfx_mant_ref;


typedef unsigned long word;
typedef unsigned short half_word;
# 64 "../../../src/systemc/datatypes/fx/scfx_mant.h"
class scfx_mant
{

    word* m_array;
    int m_size;

public:

    explicit scfx_mant( size_t );
             scfx_mant( const scfx_mant& );

    scfx_mant& operator = ( const scfx_mant& );

    ~scfx_mant();

    void clear();

    void resize_to( int, int = 0 );

    int size() const;

    word operator [] ( int ) const;
    word& operator [] ( int );

    half_word half_at( int ) const;
    half_word& half_at( int );

    half_word* half_addr( int = 0 ) const;

private:

    static word* alloc( size_t );
    static void free( word*, size_t );

    static word* alloc_word( size_t size );
    static void free_word( word* array, size_t size );

};




inline
int
scfx_mant::size() const
{
    return m_size;
}


inline
word*
scfx_mant::alloc( size_t size )
{



    return alloc_word( size );

}

inline
void
scfx_mant::free( word* mant, size_t size )
{



    free_word( mant, size );

}

inline
word
scfx_mant::operator[]( int i ) const
{
    ;



    return m_array[i];

}

inline
word&
scfx_mant::operator[]( int i )
{
    ;



    return m_array[i];

}

inline
scfx_mant::scfx_mant( size_t size )
{
    m_array = alloc( m_size = size );
}

inline
scfx_mant::scfx_mant( const scfx_mant& rhs )
{
    m_array = alloc( m_size = rhs.m_size );
    for( int i = 0; i < m_size; i ++ )
    {
        (*this)[i] = rhs[i];
    }
}

inline
scfx_mant&
scfx_mant::operator = ( const scfx_mant& rhs )
{
    if( &rhs != this )
    {
        if( m_size != rhs.m_size )
 {
     free( m_array, m_size );
     m_array = alloc( m_size = rhs.m_size );
 }

 for( int i = 0; i < m_size; i ++ )
 {
     (*this)[i] = rhs[i];
 }
    }
    return *this;
}

inline
scfx_mant::~scfx_mant()
{
    if( m_array != 0 )
    {
        free( m_array, m_size );
    }
}

inline
void
scfx_mant::clear()
{
    for( int i = 0; i < m_size; i ++ )
    {
        (*this)[i] = 0;
    }
}

inline
void
scfx_mant::resize_to( int size, int restore )
{
    if( size == m_size )
    {
        return;
    }

    if( ! m_array )
    {
        m_array = alloc( m_size = size );
    }
    else
    {
        word* p = alloc( size );

 if( restore )
 {
     int end = sc_min( size, m_size );
     if( restore == 1 )
     {
         for( int i = 0; i < size; i ++ )
  {
      if( i < end )
      {



   p[i] = m_array[i];

      }
      else
      {



   p[i] = 0;

      }
  }
     }
     else
     {
         for( int i = 0; i < size; i ++ )
  {
      if( i < end )
      {



   p[size-1-i] = m_array[m_size-1-i];

      }
      else
      {



   p[size-1-i] = 0;

      }
  }
     }
 }

 free( m_array, m_size );
 m_array = p;
 m_size = size;
    }
}

inline
half_word
scfx_mant::half_at( int i ) const
{
    ;




    return reinterpret_cast<half_word*>( m_array )[i];

}

inline
half_word&
scfx_mant::half_at( int i )
{
    ;




    return reinterpret_cast<half_word*>( m_array )[i];

}

inline
half_word*
scfx_mant::half_addr( int i ) const
{
    ;



    return reinterpret_cast<half_word*>( m_array + i );

}






inline
void
complement( scfx_mant& target, const scfx_mant& source, int size )
{
    for( int i = 0; i < size; i ++ )
    {
        target[i] = ~source[i];
    }
}






inline
void
inc( scfx_mant& mant )
{
    for( int i = 0; i < mant.size(); i ++ )
    {
        if( ++ mant[i] )
 {
     break;
 }
    }
}
# 365 "../../../src/systemc/datatypes/fx/scfx_mant.h"
class scfx_mant_ref
{

    scfx_mant* m_mant;
    bool m_not_const;

public:

    scfx_mant_ref();
    scfx_mant_ref( const scfx_mant& );
    scfx_mant_ref( scfx_mant* );

    scfx_mant_ref& operator = ( const scfx_mant& );
    scfx_mant_ref& operator = ( scfx_mant* );

    ~scfx_mant_ref();

    operator scfx_mant&();

    word operator [] ( int );

private:

    void remove_it();

    scfx_mant_ref( const scfx_mant_ref& );
    scfx_mant_ref& operator = ( const scfx_mant_ref& );

    void* operator new( size_t sz ) { return ::operator new( sz ); }

};




inline
void
scfx_mant_ref::remove_it()
{
    if( m_not_const )
    {
        delete m_mant;
    }
}

inline
scfx_mant_ref::scfx_mant_ref()
: m_mant( 0 ), m_not_const( false )
{}

inline
scfx_mant_ref::scfx_mant_ref( const scfx_mant& mant )
: m_mant( const_cast<scfx_mant*>( &mant ) ), m_not_const( false )
{}

inline
scfx_mant_ref::scfx_mant_ref( scfx_mant* mant )
: m_mant( mant ), m_not_const( true )
{}

inline
scfx_mant_ref&
scfx_mant_ref::operator = ( const scfx_mant& mant )
{
    remove_it();

    m_mant = const_cast<scfx_mant*>( &mant );
    m_not_const = false;

    return *this;
}

inline
scfx_mant_ref&
scfx_mant_ref::operator = ( scfx_mant* mant )
{
    remove_it();

    m_mant = mant;
    m_not_const = true;

    return *this;
}

inline
scfx_mant_ref::~scfx_mant_ref()
{
    remove_it();
}

inline
scfx_mant_ref::operator scfx_mant&()
{

    return *m_mant;
}

inline
word
scfx_mant_ref::operator [] ( int i )
{
    return (*m_mant)[i];
}

}
# 44 "../../../src/systemc/datatypes/fx/scfx_rep.h" 2




namespace sc_dt
{


class scfx_index;
class scfx_rep;


class sc_bv_base;
class sc_signed;
class sc_unsigned;


const int min_mant = 4;

const int bits_in_int = sizeof(int) * 8;
const int bits_in_word = sizeof(word) * 8;






class scfx_index
{

public:

    scfx_index( int wi_, int bi_ ) : m_wi( wi_ ), m_bi( bi_ ) {}

    int wi() const { return m_wi; }
    int bi() const { return m_bi; }

    void wi( int wi_ ) { m_wi = wi_; }

private:

    int m_wi;
    int m_bi;

};
# 97 "../../../src/systemc/datatypes/fx/scfx_rep.h"
class scfx_rep
{
    enum state
    {
        normal,
        infinity,
        not_a_number
    };

public:



             scfx_rep();
    explicit scfx_rep( int );
    explicit scfx_rep( unsigned int );
    explicit scfx_rep( long );
    explicit scfx_rep( unsigned long );
    explicit scfx_rep( double );
    explicit scfx_rep( const char* );
    explicit scfx_rep( int64 );
    explicit scfx_rep( uint64 );
    explicit scfx_rep( const sc_signed& );
    explicit scfx_rep( const sc_unsigned& );




             scfx_rep( const scfx_rep& );




    ~scfx_rep();


    void* operator new( size_t );
    void operator delete( void*, size_t );


    void from_string( const char*, int );

    double to_double() const;

    const char* to_string( sc_numrep,
      int,
      sc_fmt,
      const scfx_params* = 0 ) const;




    void operator = ( const scfx_rep& );

    friend void multiply( scfx_rep&, const scfx_rep&, const scfx_rep&,
     int = SC_DEFAULT_MAX_WL_ );

    friend scfx_rep* neg_scfx_rep( const scfx_rep& );
    friend scfx_rep* mult_scfx_rep( const scfx_rep&, const scfx_rep&,
         int = SC_DEFAULT_MAX_WL_ );
    friend scfx_rep* div_scfx_rep( const scfx_rep&, const scfx_rep&,
         int = SC_DEFAULT_DIV_WL_ );
    friend scfx_rep* add_scfx_rep( const scfx_rep&, const scfx_rep&,
         int = SC_DEFAULT_MAX_WL_ );
    friend scfx_rep* sub_scfx_rep( const scfx_rep&, const scfx_rep&,
         int = SC_DEFAULT_MAX_WL_ );
    friend scfx_rep* lsh_scfx_rep( const scfx_rep&, int );
    friend scfx_rep* rsh_scfx_rep( const scfx_rep&, int );

    void lshift( int );
    void rshift( int );

    friend int cmp_scfx_rep( const scfx_rep&, const scfx_rep& );

    void cast( const scfx_params&, bool&, bool& );

    bool is_neg() const;
    bool is_zero() const;
    bool is_nan() const;
    bool is_inf() const;
    bool is_normal() const;

    void set_zero( int = 1 );
    void set_nan();
    void set_inf( int );

    bool get_bit( int ) const;
    bool set( int, const scfx_params& );
    bool clear( int, const scfx_params& );

    bool get_slice( int, int, const scfx_params&, sc_bv_base& ) const;
    bool set_slice( int, int, const scfx_params&, const sc_bv_base& );

    void print( ostream& ) const;
    void dump( ostream& ) const;

    void get_type( int&, int&, sc_enc& ) const;

    friend scfx_rep* quantization_scfx_rep( const scfx_rep&,
          const scfx_params&,
          bool& );
    friend scfx_rep* overflow_scfx_rep( const scfx_rep&,
          const scfx_params&,
          bool& );

    bool rounding_flag() const;

private:

    friend void align( const scfx_rep&, const scfx_rep&, int&, int&,
   scfx_mant_ref&, scfx_mant_ref& );
    friend int compare_msw( const scfx_rep&, const scfx_rep& );
    friend int compare_msw_ff( const scfx_rep& lhs, const scfx_rep& rhs );
    unsigned int divide_by_ten();
    int find_lsw() const;
    int find_msw() const;
    void find_sw();
    void multiply_by_ten();
    void normalize( int );
    scfx_mant* resize( int, int ) const;
    void set_bin( int );
    void set_oct( int, int );
    void set_hex( int, int );
    void shift_left( int );
    void shift_right( int );

    const scfx_index calc_indices( int ) const;

    void o_extend( const scfx_index&, sc_enc );
    bool o_bit_at( const scfx_index& ) const;
    bool o_zero_left( const scfx_index& ) const;
    bool o_zero_right( const scfx_index& ) const;
    void o_set_low( const scfx_index&, sc_enc );
    void o_set_high( const scfx_index&, const scfx_index&, sc_enc, int = 1 );
    void o_set( const scfx_index&, const scfx_index&, sc_enc, bool );
    void o_invert( const scfx_index& );
    bool q_bit( const scfx_index& ) const;
    void q_clear( const scfx_index& );
    void q_incr( const scfx_index& );
    bool q_odd( const scfx_index& ) const;
    bool q_zero( const scfx_index& ) const;

    void resize_to( int, int = 0 );
    int size() const;
    void toggle_tc();

    friend void print_dec( scfx_string&, const scfx_rep&, int, sc_fmt );
    friend void print_other( scfx_string&, const scfx_rep&, sc_numrep, int,
        sc_fmt, const scfx_params* );

    void quantization( const scfx_params&, bool& );
    void overflow( const scfx_params&, bool& );

    friend int compare_abs( const scfx_rep&, const scfx_rep& );

    void round( int );

private:

    scfx_mant m_mant;
    int m_wp;
    int m_sign;
    state m_state;
    int m_msw;
    int m_lsw;
    bool m_r_flag;

};




inline
void
scfx_rep::set_zero( int sign )
{
    m_mant.clear();
    m_wp = m_msw = m_lsw = 0;
    m_sign = sign;
    m_state = normal;
}

inline
void
scfx_rep::set_nan()
{
    m_mant.resize_to( min_mant );
    m_state = not_a_number;
}

inline
void
scfx_rep::set_inf( int sign )
{
    m_mant.resize_to( min_mant );
    m_state = infinity;
    m_sign = sign;
}




inline
scfx_rep::scfx_rep( const char* s )
: m_mant( min_mant ), m_wp( 2 ), m_sign( 1 ), m_state( normal ),
  m_r_flag( false )
{
    from_string( s, SC_DEFAULT_CTE_WL_ );
}




inline
scfx_rep::~scfx_rep()
{}




inline
void
scfx_rep::operator = ( const scfx_rep& f )
{
    if( &f != this )
    {
        m_mant = f.m_mant;
 m_wp = f.m_wp;
 m_sign = f.m_sign;
 m_state = f.m_state;
 m_msw = f.m_msw;
 m_lsw = f.m_lsw;
 round( SC_DEFAULT_MAX_WL_ );
    }
}

inline
scfx_rep*
neg_scfx_rep( const scfx_rep& a )
{
    scfx_rep& c = *new scfx_rep( a );
    c.m_sign = - c.m_sign;
    return &c;
}

inline
scfx_rep*
mult_scfx_rep( const scfx_rep& a, const scfx_rep& b, int max_wl )
{
    scfx_rep& c = *new scfx_rep;
    sc_dt::multiply( c, a, b, max_wl );
    return &c;
}

inline
scfx_rep*
lsh_scfx_rep( const scfx_rep& a, int b )
{
    scfx_rep& c = *new scfx_rep( a );
    c.lshift( b );
    return &c;
}

inline
scfx_rep*
rsh_scfx_rep( const scfx_rep& a, int b )
{
    scfx_rep& c = *new scfx_rep( a );
    c.rshift( b );
    return &c;
}

inline
int
scfx_rep::size() const
{
    return m_mant.size();
}

inline
bool
scfx_rep::is_neg() const
{
    return ( m_sign == -1 );
}

inline
bool
scfx_rep::is_zero() const
{
    if( m_state != normal )
        return false;

    for( int i = 0; i < size(); i ++ )
    {
        if( m_mant[i] )
     return false;
    }

    return true;
}

inline
bool
scfx_rep::is_nan() const
{
    return ( m_state == not_a_number );
}

inline
bool
scfx_rep::is_inf() const
{
    return ( m_state == infinity );
}

inline
bool
scfx_rep::is_normal() const
{
    return ( m_state == normal );
}

inline
scfx_rep*
quantization_scfx_rep( const scfx_rep& a,
   const scfx_params& params,
   bool& q_flag )
{
    scfx_rep& c = *new scfx_rep( a );
    c.quantization( params, q_flag );
    return &c;
}

inline
scfx_rep*
overflow_scfx_rep( const scfx_rep& a,
      const scfx_params& params,
      bool& o_flag )
{
    scfx_rep& c = *new scfx_rep( a );
    c.overflow( params, o_flag );
    return &c;
}

inline
bool
scfx_rep::rounding_flag() const
{
    return m_r_flag;
}

inline
void
scfx_rep::resize_to( int new_size, int restore )
{
    if( restore == -1 )
    {
        int size_incr = new_size - size();
 m_wp += size_incr;
 m_msw += size_incr;
 m_lsw += size_incr;
    }
    m_mant.resize_to( new_size, restore );
}

inline
const scfx_index
scfx_rep::calc_indices( int n ) const
{
    int wi = n / bits_in_word + m_wp;
    int bi = n % bits_in_word;

    if( bi < 0 )
    {
        bi += bits_in_word;
 -- wi;
    }

    return scfx_index( wi, bi );
}

inline
void
scfx_rep::o_extend( const scfx_index& x, sc_enc enc )
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    if( enc == SC_US_ || ( m_mant[wi] & ( 1 << bi ) ) == 0 )
    {
        if( bi != bits_in_word - 1 )
     m_mant[wi] &= ~( -1 << ( bi + 1 ) );
 for( int i = wi + 1; i < size(); ++ i )
     m_mant[i] = 0;
 m_sign = 1;
    }
    else
    {
        if( bi != bits_in_word - 1 )
     m_mant[wi] |= ( -1 << ( bi + 1 ) );
 for( int i = wi + 1; i < size(); ++ i )
     m_mant[i] = static_cast<word>( -1 );
 m_sign = -1;
    }
}

inline
bool
scfx_rep::o_bit_at( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    return ( m_mant[wi] & ( 1 << bi ) ) != 0;
}

inline
bool
scfx_rep::o_zero_left( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    bool zero = true;
    if( bi != bits_in_word - 1 )
        zero = ( m_mant[wi] & ( -1 << ( bi + 1 ) ) ) == 0;
    for( int i = wi + 1; i < size(); ++ i )
 zero = zero && m_mant[i] == 0;

    return zero;
}

inline
bool
scfx_rep::o_zero_right( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    bool zero = ( m_mant[wi] & ~( -1 << bi ) ) == 0;
    for( int i = wi - 1; i >= 0; -- i )
 zero = zero && m_mant[i] == 0;

    return zero;
}

inline
void
scfx_rep::o_set_low( const scfx_index& x, sc_enc enc )
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    m_mant.clear();

    if( enc == SC_TC_ )
    {
 m_mant[wi] |= ( 1 << bi );
 m_sign = -1;
    }
    else
 m_sign = 1;
}

inline
void
scfx_rep::o_set_high( const scfx_index& x, const scfx_index& x2,
        sc_enc enc, int sign )
{
    int wi = x.wi();
    int bi = x.bi();
    int wi2 = x2.wi();
    int bi2 = x2.bi();

    ;
    ;

    int i;

    for( i = 0; i < size(); ++ i )
 m_mant[i] = static_cast<word>( -1 );

    m_mant[wi] &= ~( -1 << bi );
    for( i = wi + 1; i < size(); ++ i )
 m_mant[i] = 0;

    m_mant[wi2] &= ( -1 << bi2 );
    for( i = wi2 - 1; i >= 0; -- i )
 m_mant[i] = 0;

    if( enc == SC_TC_ )
 m_sign = sign;
    else
    {
 m_mant[wi] |= ( 1 << bi );
 m_sign = 1;
    }
}

inline
void
scfx_rep::o_set( const scfx_index& x, const scfx_index& x3,
   sc_enc enc, bool under )
{
    int wi = x.wi();
    int bi = x.bi();
    int wi3 = x3.wi();
    int bi3 = x3.bi();

    ;
    ;

    if( bi3 != bits_in_word - 1 )
    {
 if( under )
     m_mant[wi3] &= ~( -1 << ( bi3 + 1 ) );
 else
     m_mant[wi3] |= ( -1 << ( bi3 + 1 ) );
    }
    for( int i = wi3 + 1; i < size(); ++ i )
    {
 if( under )
     m_mant[i] = 0;
 else
     m_mant[i] = static_cast<word>( -1 );
    }

    if( enc == SC_TC_ )
    {
 if( under )
     m_mant[wi] |= ( 1 << bi );
 else
     m_mant[wi] &= ~( 1 << bi );
    }
}

inline
void
scfx_rep::o_invert( const scfx_index& x2 )
{
    int wi2 = x2.wi();
    int bi2 = x2.bi();

    m_mant[wi2] ^= ( -1 << bi2 );
    for( int i = wi2 + 1; i < size(); ++ i )
 m_mant[i] = ~ m_mant[i];
}

inline
bool
scfx_rep::q_bit( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    if( bi != 0 )
        return ( m_mant[wi] & ( 1 << ( bi - 1 ) ) ) != 0;
    else if( wi != 0 )
        return ( m_mant[wi - 1] & ( 1 << ( bits_in_word - 1 ) ) ) != 0;
    else
        return false;
}

inline
void
scfx_rep::q_clear( const scfx_index& x )
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    m_mant[wi] &= ( -1 << bi );
    for( int i = wi - 1; i >= 0; -- i )
        m_mant[i] = 0;
}

inline
void
scfx_rep::q_incr( const scfx_index& x )
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    word old_val = m_mant[wi];
    m_mant[wi] += ( 1 << bi );
    if( m_mant[wi] <= old_val )
    {
        if( wi + 1 == size() )
          resize_to( size() + 1, 1 );

        for( int i = wi + 1; i < size(); ++ i )
 {
     if( ++ m_mant[i] != 0 )
         break;
 }
    }
}

inline
bool
scfx_rep::q_odd( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    return ( m_mant[wi] & ( 1 << bi ) ) != 0;
}

inline
bool
scfx_rep::q_zero( const scfx_index& x ) const
{
    int wi = x.wi();
    int bi = x.bi();

    ;

    bool zero;

    if( bi != 0 )
    {
        zero = ( m_mant[wi] & ~( -1 << (bi - 1) ) ) == 0;
 for( int i = wi - 1; i >= 0; -- i )
     zero = zero && m_mant[i] == 0;
    }
    else if( wi != 0 )
    {
        zero = ( m_mant[wi - 1] & ~( -1 << (bits_in_word - 1) ) ) == 0;
 for( int i = wi - 2; i >= 0; -- i )
     zero = zero && m_mant[i] == 0;
    }
    else
        zero = true;

    return zero;
}

inline
int
scfx_rep::find_lsw() const
{
    for( int i = 0; i < size(); i ++ )
    {
        if( m_mant[i] )
     return i;
    }
    return 0;
}

inline
int
scfx_rep::find_msw() const
{
    for( int i = size() - 1; i >= 0; i -- )
    {
        if( m_mant[i] )
     return i;
    }
    return 0;
}

inline
void
scfx_rep::find_sw()
{
    m_lsw = find_lsw();
    m_msw = find_msw();
}

inline
void
scfx_rep::toggle_tc()
{
    if( is_neg() )
    {
        complement( m_mant, m_mant, m_mant.size() );
 inc( m_mant );
    }
}

}
# 41 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2

# 1 "../../../src/systemc/datatypes/int/sc_int_base.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_uint_base.h" 1
# 44 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_signed.h" 1
# 45 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2
# 1 "../../../src/systemc/datatypes/int/sc_unsigned.h" 1
# 46 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2

# 1 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h"
namespace sc_dt
{


class sc_fxval_observer;
class sc_fxval_fast_observer;


class sc_fxval;
class sc_fxval_fast;
# 103 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h"
class sc_fxval_observer
{

protected:

    sc_fxval_observer() {}
    virtual ~sc_fxval_observer() {}

public:

    virtual void construct( const sc_fxval& );
    virtual void destruct( const sc_fxval& );
    virtual void read( const sc_fxval& );
    virtual void write( const sc_fxval& );

    static sc_fxval_observer* (*default_observer) ();

};
# 130 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h"
class sc_fxval_fast_observer
{

protected:

    sc_fxval_fast_observer() {}
    virtual ~sc_fxval_fast_observer() {}

public:

    virtual void construct( const sc_fxval_fast& );
    virtual void destruct( const sc_fxval_fast& );
    virtual void read( const sc_fxval_fast& );
    virtual void write( const sc_fxval_fast& );

    static sc_fxval_fast_observer* (*default_observer) ();

};
# 159 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h"
inline
void
sc_fxval_observer::construct( const sc_fxval& )
{}

inline
void
sc_fxval_observer::destruct( const sc_fxval& )
{}

inline
void
sc_fxval_observer::read( const sc_fxval& )
{}

inline
void
sc_fxval_observer::write( const sc_fxval& )
{}
# 187 "../../../src/systemc/datatypes/fx/sc_fxval_observer.h"
inline
void
sc_fxval_fast_observer::construct( const sc_fxval_fast& )
{}

inline
void
sc_fxval_fast_observer::destruct( const sc_fxval_fast& )
{}

inline
void
sc_fxval_fast_observer::read( const sc_fxval_fast& )
{}

inline
void
sc_fxval_fast_observer::write( const sc_fxval_fast& )
{}

}
# 48 "../../../src/systemc/datatypes/fx/sc_fxval.h" 2


namespace sc_dt
{


class sc_fxval;
class sc_fxval_fast;


class sc_fxnum;
class sc_fxnum_fast;
# 68 "../../../src/systemc/datatypes/fx/sc_fxval.h"
class sc_fxval
{

    friend class sc_fxnum;

protected:

    sc_fxval_observer* observer() const;

public:


    sc_fxval( scfx_rep* );


    explicit sc_fxval( sc_fxval_observer* = 0 );
             sc_fxval( int,
         sc_fxval_observer* = 0 );
             sc_fxval( unsigned int,
         sc_fxval_observer* = 0 );
             sc_fxval( long,
         sc_fxval_observer* = 0 );
             sc_fxval( unsigned long,
         sc_fxval_observer* = 0 );
             sc_fxval( double,
         sc_fxval_observer* = 0 );
             sc_fxval( const char*,
         sc_fxval_observer* = 0 );
             sc_fxval( const sc_fxval&,
         sc_fxval_observer* = 0 );
             sc_fxval( const sc_fxval_fast&,
         sc_fxval_observer* = 0 );
             sc_fxval( const sc_fxnum&,
         sc_fxval_observer* = 0 );
             sc_fxval( const sc_fxnum_fast&,
         sc_fxval_observer* = 0 );

    explicit sc_fxval( int64,
         sc_fxval_observer* = 0 );
    explicit sc_fxval( uint64,
         sc_fxval_observer* = 0 );
    explicit sc_fxval( const sc_int_base&,
         sc_fxval_observer* = 0 );
    explicit sc_fxval( const sc_uint_base&,
         sc_fxval_observer* = 0 );
    explicit sc_fxval( const sc_signed&,
         sc_fxval_observer* = 0 );
    explicit sc_fxval( const sc_unsigned&,
         sc_fxval_observer* = 0 );


    ~sc_fxval();



    const scfx_rep* get_rep() const;
    void set_rep( scfx_rep* );




    const sc_fxval operator - () const;
    const sc_fxval& operator + () const;




    friend void neg( sc_fxval&, const sc_fxval& );
# 168 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend const sc_fxval operator * ( const sc_fxval&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, int ); friend const sc_fxval operator * ( int, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, unsigned int ); friend const sc_fxval operator * ( unsigned int, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, long ); friend const sc_fxval operator * ( long, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, unsigned long ); friend const sc_fxval operator * ( unsigned long, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, double ); friend const sc_fxval operator * ( double, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const char* ); friend const sc_fxval operator * ( const char*, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_fxval_fast& ); friend const sc_fxval operator * ( const sc_fxval_fast&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_fxnum_fast& ); friend const sc_fxval operator * ( const sc_fxnum_fast&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, int64 ); friend const sc_fxval operator * ( int64, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, uint64 ); friend const sc_fxval operator * ( uint64, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_int_base& ); friend const sc_fxval operator * ( const sc_int_base&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_uint_base& ); friend const sc_fxval operator * ( const sc_uint_base&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_signed& ); friend const sc_fxval operator * ( const sc_signed&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_unsigned& ); friend const sc_fxval operator * ( const sc_unsigned&, const sc_fxval& );
    friend const sc_fxval operator + ( const sc_fxval&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, int ); friend const sc_fxval operator + ( int, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, unsigned int ); friend const sc_fxval operator + ( unsigned int, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, long ); friend const sc_fxval operator + ( long, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, unsigned long ); friend const sc_fxval operator + ( unsigned long, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, double ); friend const sc_fxval operator + ( double, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const char* ); friend const sc_fxval operator + ( const char*, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_fxval_fast& ); friend const sc_fxval operator + ( const sc_fxval_fast&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_fxnum_fast& ); friend const sc_fxval operator + ( const sc_fxnum_fast&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, int64 ); friend const sc_fxval operator + ( int64, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, uint64 ); friend const sc_fxval operator + ( uint64, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_int_base& ); friend const sc_fxval operator + ( const sc_int_base&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_uint_base& ); friend const sc_fxval operator + ( const sc_uint_base&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_signed& ); friend const sc_fxval operator + ( const sc_signed&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_unsigned& ); friend const sc_fxval operator + ( const sc_unsigned&, const sc_fxval& );
    friend const sc_fxval operator - ( const sc_fxval&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, int ); friend const sc_fxval operator - ( int, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, unsigned int ); friend const sc_fxval operator - ( unsigned int, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, long ); friend const sc_fxval operator - ( long, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, unsigned long ); friend const sc_fxval operator - ( unsigned long, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, double ); friend const sc_fxval operator - ( double, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const char* ); friend const sc_fxval operator - ( const char*, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_fxval_fast& ); friend const sc_fxval operator - ( const sc_fxval_fast&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_fxnum_fast& ); friend const sc_fxval operator - ( const sc_fxnum_fast&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, int64 ); friend const sc_fxval operator - ( int64, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, uint64 ); friend const sc_fxval operator - ( uint64, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_int_base& ); friend const sc_fxval operator - ( const sc_int_base&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_uint_base& ); friend const sc_fxval operator - ( const sc_uint_base&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_signed& ); friend const sc_fxval operator - ( const sc_signed&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_unsigned& ); friend const sc_fxval operator - ( const sc_unsigned&, const sc_fxval& );



    friend const sc_fxval operator / ( const sc_fxval&, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, int ); friend const sc_fxval operator / ( int, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, unsigned int ); friend const sc_fxval operator / ( unsigned int, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, long ); friend const sc_fxval operator / ( long, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, unsigned long ); friend const sc_fxval operator / ( unsigned long, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, double ); friend const sc_fxval operator / ( double, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, const char* ); friend const sc_fxval operator / ( const char*, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, const sc_fxval_fast& ); friend const sc_fxval operator / ( const sc_fxval_fast&, const sc_fxval& );
    friend const sc_fxval operator / ( const sc_fxval&, const sc_fxnum_fast& ); friend const sc_fxval operator / ( const sc_fxnum_fast&, const sc_fxval& );


    friend const sc_fxval operator / ( const sc_fxval&, int64 ); friend const sc_fxval operator / ( int64, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, uint64 ); friend const sc_fxval operator / ( uint64, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, const sc_int_base& ); friend const sc_fxval operator / ( const sc_int_base&, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, const sc_uint_base& ); friend const sc_fxval operator / ( const sc_uint_base&, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, const sc_signed& ); friend const sc_fxval operator / ( const sc_signed&, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, const sc_unsigned& ); friend const sc_fxval operator / ( const sc_unsigned&, const sc_fxval& );
# 198 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend const sc_fxval operator << ( const sc_fxval&, int );
    friend const sc_fxval operator >> ( const sc_fxval&, int );
# 232 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend void mult ( sc_fxval&, const sc_fxval&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, int ); friend void mult ( sc_fxval&, int, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, unsigned int ); friend void mult ( sc_fxval&, unsigned int, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, long ); friend void mult ( sc_fxval&, long, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, unsigned long ); friend void mult ( sc_fxval&, unsigned long, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, double ); friend void mult ( sc_fxval&, double, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const char* ); friend void mult ( sc_fxval&, const char*, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_fxval_fast& ); friend void mult ( sc_fxval&, const sc_fxval_fast&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_fxnum_fast& ); friend void mult ( sc_fxval&, const sc_fxnum_fast&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, int64 ); friend void mult ( sc_fxval&, int64, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, uint64 ); friend void mult ( sc_fxval&, uint64, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_int_base& ); friend void mult ( sc_fxval&, const sc_int_base&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_uint_base& ); friend void mult ( sc_fxval&, const sc_uint_base&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_signed& ); friend void mult ( sc_fxval&, const sc_signed&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_unsigned& ); friend void mult ( sc_fxval&, const sc_unsigned&, const sc_fxval& );
    friend void div ( sc_fxval&, const sc_fxval&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, int ); friend void div ( sc_fxval&, int, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, unsigned int ); friend void div ( sc_fxval&, unsigned int, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, long ); friend void div ( sc_fxval&, long, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, unsigned long ); friend void div ( sc_fxval&, unsigned long, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, double ); friend void div ( sc_fxval&, double, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const char* ); friend void div ( sc_fxval&, const char*, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_fxval_fast& ); friend void div ( sc_fxval&, const sc_fxval_fast&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_fxnum_fast& ); friend void div ( sc_fxval&, const sc_fxnum_fast&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, int64 ); friend void div ( sc_fxval&, int64, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, uint64 ); friend void div ( sc_fxval&, uint64, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_int_base& ); friend void div ( sc_fxval&, const sc_int_base&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_uint_base& ); friend void div ( sc_fxval&, const sc_uint_base&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_signed& ); friend void div ( sc_fxval&, const sc_signed&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_unsigned& ); friend void div ( sc_fxval&, const sc_unsigned&, const sc_fxval& );
    friend void add ( sc_fxval&, const sc_fxval&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, int ); friend void add ( sc_fxval&, int, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, unsigned int ); friend void add ( sc_fxval&, unsigned int, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, long ); friend void add ( sc_fxval&, long, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, unsigned long ); friend void add ( sc_fxval&, unsigned long, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, double ); friend void add ( sc_fxval&, double, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const char* ); friend void add ( sc_fxval&, const char*, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_fxval_fast& ); friend void add ( sc_fxval&, const sc_fxval_fast&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_fxnum_fast& ); friend void add ( sc_fxval&, const sc_fxnum_fast&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, int64 ); friend void add ( sc_fxval&, int64, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, uint64 ); friend void add ( sc_fxval&, uint64, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_int_base& ); friend void add ( sc_fxval&, const sc_int_base&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_uint_base& ); friend void add ( sc_fxval&, const sc_uint_base&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_signed& ); friend void add ( sc_fxval&, const sc_signed&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_unsigned& ); friend void add ( sc_fxval&, const sc_unsigned&, const sc_fxval& );
    friend void sub ( sc_fxval&, const sc_fxval&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, int ); friend void sub ( sc_fxval&, int, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, unsigned int ); friend void sub ( sc_fxval&, unsigned int, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, long ); friend void sub ( sc_fxval&, long, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, unsigned long ); friend void sub ( sc_fxval&, unsigned long, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, double ); friend void sub ( sc_fxval&, double, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const char* ); friend void sub ( sc_fxval&, const char*, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_fxval_fast& ); friend void sub ( sc_fxval&, const sc_fxval_fast&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_fxnum_fast& ); friend void sub ( sc_fxval&, const sc_fxnum_fast&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, int64 ); friend void sub ( sc_fxval&, int64, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, uint64 ); friend void sub ( sc_fxval&, uint64, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_int_base& ); friend void sub ( sc_fxval&, const sc_int_base&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_uint_base& ); friend void sub ( sc_fxval&, const sc_uint_base&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_signed& ); friend void sub ( sc_fxval&, const sc_signed&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_unsigned& ); friend void sub ( sc_fxval&, const sc_unsigned&, const sc_fxval& );





    friend void lshift( sc_fxval&, const sc_fxval&, int );
    friend void rshift( sc_fxval&, const sc_fxval&, int );
# 275 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend bool operator < ( const sc_fxval&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, int ); friend bool operator < ( int, const sc_fxval& ); friend bool operator < ( const sc_fxval&, unsigned int ); friend bool operator < ( unsigned int, const sc_fxval& ); friend bool operator < ( const sc_fxval&, long ); friend bool operator < ( long, const sc_fxval& ); friend bool operator < ( const sc_fxval&, unsigned long ); friend bool operator < ( unsigned long, const sc_fxval& ); friend bool operator < ( const sc_fxval&, double ); friend bool operator < ( double, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const char* ); friend bool operator < ( const char*, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, int64 ); friend bool operator < ( int64, const sc_fxval& ); friend bool operator < ( const sc_fxval&, uint64 ); friend bool operator < ( uint64, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_int_base& ); friend bool operator < ( const sc_int_base&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_uint_base& ); friend bool operator < ( const sc_uint_base&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_signed& ); friend bool operator < ( const sc_signed&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_unsigned& ); friend bool operator < ( const sc_unsigned&, const sc_fxval& );
    friend bool operator <= ( const sc_fxval&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, int ); friend bool operator <= ( int, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, unsigned int ); friend bool operator <= ( unsigned int, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, long ); friend bool operator <= ( long, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, unsigned long ); friend bool operator <= ( unsigned long, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, double ); friend bool operator <= ( double, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const char* ); friend bool operator <= ( const char*, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, int64 ); friend bool operator <= ( int64, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, uint64 ); friend bool operator <= ( uint64, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_int_base& ); friend bool operator <= ( const sc_int_base&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_uint_base& ); friend bool operator <= ( const sc_uint_base&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_signed& ); friend bool operator <= ( const sc_signed&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_unsigned& ); friend bool operator <= ( const sc_unsigned&, const sc_fxval& );
    friend bool operator > ( const sc_fxval&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, int ); friend bool operator > ( int, const sc_fxval& ); friend bool operator > ( const sc_fxval&, unsigned int ); friend bool operator > ( unsigned int, const sc_fxval& ); friend bool operator > ( const sc_fxval&, long ); friend bool operator > ( long, const sc_fxval& ); friend bool operator > ( const sc_fxval&, unsigned long ); friend bool operator > ( unsigned long, const sc_fxval& ); friend bool operator > ( const sc_fxval&, double ); friend bool operator > ( double, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const char* ); friend bool operator > ( const char*, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, int64 ); friend bool operator > ( int64, const sc_fxval& ); friend bool operator > ( const sc_fxval&, uint64 ); friend bool operator > ( uint64, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_int_base& ); friend bool operator > ( const sc_int_base&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_uint_base& ); friend bool operator > ( const sc_uint_base&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_signed& ); friend bool operator > ( const sc_signed&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_unsigned& ); friend bool operator > ( const sc_unsigned&, const sc_fxval& );
    friend bool operator >= ( const sc_fxval&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, int ); friend bool operator >= ( int, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, unsigned int ); friend bool operator >= ( unsigned int, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, long ); friend bool operator >= ( long, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, unsigned long ); friend bool operator >= ( unsigned long, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, double ); friend bool operator >= ( double, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const char* ); friend bool operator >= ( const char*, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, int64 ); friend bool operator >= ( int64, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, uint64 ); friend bool operator >= ( uint64, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_int_base& ); friend bool operator >= ( const sc_int_base&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_uint_base& ); friend bool operator >= ( const sc_uint_base&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_signed& ); friend bool operator >= ( const sc_signed&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_unsigned& ); friend bool operator >= ( const sc_unsigned&, const sc_fxval& );
    friend bool operator == ( const sc_fxval&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, int ); friend bool operator == ( int, const sc_fxval& ); friend bool operator == ( const sc_fxval&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxval& ); friend bool operator == ( const sc_fxval&, long ); friend bool operator == ( long, const sc_fxval& ); friend bool operator == ( const sc_fxval&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxval& ); friend bool operator == ( const sc_fxval&, double ); friend bool operator == ( double, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const char* ); friend bool operator == ( const char*, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, int64 ); friend bool operator == ( int64, const sc_fxval& ); friend bool operator == ( const sc_fxval&, uint64 ); friend bool operator == ( uint64, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_int_base& ); friend bool operator == ( const sc_int_base&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_uint_base& ); friend bool operator == ( const sc_uint_base&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxval& );
    friend bool operator != ( const sc_fxval&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, int ); friend bool operator != ( int, const sc_fxval& ); friend bool operator != ( const sc_fxval&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxval& ); friend bool operator != ( const sc_fxval&, long ); friend bool operator != ( long, const sc_fxval& ); friend bool operator != ( const sc_fxval&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxval& ); friend bool operator != ( const sc_fxval&, double ); friend bool operator != ( double, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const char* ); friend bool operator != ( const char*, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, int64 ); friend bool operator != ( int64, const sc_fxval& ); friend bool operator != ( const sc_fxval&, uint64 ); friend bool operator != ( uint64, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_int_base& ); friend bool operator != ( const sc_int_base&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_uint_base& ); friend bool operator != ( const sc_uint_base&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxval& );
# 317 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    sc_fxval& operator =( int ); sc_fxval& operator =( unsigned int ); sc_fxval& operator =( long ); sc_fxval& operator =( unsigned long ); sc_fxval& operator =( double ); sc_fxval& operator =( const char* ); sc_fxval& operator =( const sc_fxval& ); sc_fxval& operator =( const sc_fxval_fast& ); sc_fxval& operator =( const sc_fxnum& ); sc_fxval& operator =( const sc_fxnum_fast& ); sc_fxval& operator =( int64 ); sc_fxval& operator =( uint64 ); sc_fxval& operator =( const sc_int_base& ); sc_fxval& operator =( const sc_uint_base& ); sc_fxval& operator =( const sc_signed& ); sc_fxval& operator =( const sc_unsigned& );

    sc_fxval& operator *=( int ); sc_fxval& operator *=( unsigned int ); sc_fxval& operator *=( long ); sc_fxval& operator *=( unsigned long ); sc_fxval& operator *=( double ); sc_fxval& operator *=( const char* ); sc_fxval& operator *=( const sc_fxval& ); sc_fxval& operator *=( const sc_fxval_fast& ); sc_fxval& operator *=( const sc_fxnum& ); sc_fxval& operator *=( const sc_fxnum_fast& ); sc_fxval& operator *=( int64 ); sc_fxval& operator *=( uint64 ); sc_fxval& operator *=( const sc_int_base& ); sc_fxval& operator *=( const sc_uint_base& ); sc_fxval& operator *=( const sc_signed& ); sc_fxval& operator *=( const sc_unsigned& );
    sc_fxval& operator /=( int ); sc_fxval& operator /=( unsigned int ); sc_fxval& operator /=( long ); sc_fxval& operator /=( unsigned long ); sc_fxval& operator /=( double ); sc_fxval& operator /=( const char* ); sc_fxval& operator /=( const sc_fxval& ); sc_fxval& operator /=( const sc_fxval_fast& ); sc_fxval& operator /=( const sc_fxnum& ); sc_fxval& operator /=( const sc_fxnum_fast& ); sc_fxval& operator /=( int64 ); sc_fxval& operator /=( uint64 ); sc_fxval& operator /=( const sc_int_base& ); sc_fxval& operator /=( const sc_uint_base& ); sc_fxval& operator /=( const sc_signed& ); sc_fxval& operator /=( const sc_unsigned& );
    sc_fxval& operator +=( int ); sc_fxval& operator +=( unsigned int ); sc_fxval& operator +=( long ); sc_fxval& operator +=( unsigned long ); sc_fxval& operator +=( double ); sc_fxval& operator +=( const char* ); sc_fxval& operator +=( const sc_fxval& ); sc_fxval& operator +=( const sc_fxval_fast& ); sc_fxval& operator +=( const sc_fxnum& ); sc_fxval& operator +=( const sc_fxnum_fast& ); sc_fxval& operator +=( int64 ); sc_fxval& operator +=( uint64 ); sc_fxval& operator +=( const sc_int_base& ); sc_fxval& operator +=( const sc_uint_base& ); sc_fxval& operator +=( const sc_signed& ); sc_fxval& operator +=( const sc_unsigned& );
    sc_fxval& operator -=( int ); sc_fxval& operator -=( unsigned int ); sc_fxval& operator -=( long ); sc_fxval& operator -=( unsigned long ); sc_fxval& operator -=( double ); sc_fxval& operator -=( const char* ); sc_fxval& operator -=( const sc_fxval& ); sc_fxval& operator -=( const sc_fxval_fast& ); sc_fxval& operator -=( const sc_fxnum& ); sc_fxval& operator -=( const sc_fxnum_fast& ); sc_fxval& operator -=( int64 ); sc_fxval& operator -=( uint64 ); sc_fxval& operator -=( const sc_int_base& ); sc_fxval& operator -=( const sc_uint_base& ); sc_fxval& operator -=( const sc_signed& ); sc_fxval& operator -=( const sc_unsigned& );

    sc_fxval& operator <<=( int );
    sc_fxval& operator >>=( int );
# 334 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    const sc_fxval operator ++ ( int );
    const sc_fxval operator -- ( int );

    sc_fxval& operator ++ ();
    sc_fxval& operator -- ();




    operator double() const;




    short to_short() const;
    unsigned short to_ushort() const;
    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    float to_float() const;
    double to_double() const;




    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;
    const sc_string to_string( sc_fmt ) const;
    const sc_string to_string( sc_numrep, sc_fmt ) const;
    const sc_string to_string( sc_numrep, bool, sc_fmt ) const;

    const sc_string to_dec() const;
    const sc_string to_bin() const;
    const sc_string to_oct() const;
    const sc_string to_hex() const;




    bool is_neg() const;
    bool is_zero() const;
    bool is_nan() const;
    bool is_inf() const;
    bool is_normal() const;

    bool rounding_flag() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;



    bool get_bit( int ) const;

protected:

    sc_fxval_observer* lock_observer() const;
    void unlock_observer( sc_fxval_observer* ) const;


    void get_type( int&, int&, sc_enc& ) const;

    const sc_fxval quantization( const scfx_params&, bool& ) const;
    const sc_fxval overflow( const scfx_params&, bool& ) const;

private:

    scfx_rep* m_rep;

    mutable sc_fxval_observer* m_observer;

};
# 420 "../../../src/systemc/datatypes/fx/sc_fxval.h"
class sc_fxval_fast
{

    friend class sc_fxnum_fast;

protected:

    sc_fxval_fast_observer* observer() const;

public:

    explicit sc_fxval_fast( sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( int,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( unsigned int,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( long,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( unsigned long,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( double,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( const char*,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( const sc_fxval&,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( const sc_fxval_fast&,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( const sc_fxnum&,
       sc_fxval_fast_observer* = 0 );
             sc_fxval_fast( const sc_fxnum_fast&,
       sc_fxval_fast_observer* = 0 );

    explicit sc_fxval_fast( int64,
       sc_fxval_fast_observer* = 0 );
    explicit sc_fxval_fast( uint64,
       sc_fxval_fast_observer* = 0 );
    explicit sc_fxval_fast( const sc_int_base&,
       sc_fxval_fast_observer* = 0 );
    explicit sc_fxval_fast( const sc_uint_base&,
       sc_fxval_fast_observer* = 0 );
    explicit sc_fxval_fast( const sc_signed&,
       sc_fxval_fast_observer* = 0 );
    explicit sc_fxval_fast( const sc_unsigned&,
       sc_fxval_fast_observer* = 0 );


    ~sc_fxval_fast();


    double get_val() const;
    void set_val( double );




    const sc_fxval_fast operator - () const;
    const sc_fxval_fast& operator + () const;




    friend void neg( sc_fxval_fast&, const sc_fxval_fast& );
# 514 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, int ); friend const sc_fxval_fast operator * ( int, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, unsigned int ); friend const sc_fxval_fast operator * ( unsigned int, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, long ); friend const sc_fxval_fast operator * ( long, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, unsigned long ); friend const sc_fxval_fast operator * ( unsigned long, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, double ); friend const sc_fxval_fast operator * ( double, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const char* ); friend const sc_fxval_fast operator * ( const char*, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, int64 ); friend const sc_fxval_fast operator * ( int64, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, uint64 ); friend const sc_fxval_fast operator * ( uint64, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_int_base& ); friend const sc_fxval_fast operator * ( const sc_int_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator * ( const sc_uint_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_signed& ); friend const sc_fxval_fast operator * ( const sc_signed&, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator * ( const sc_unsigned&, const sc_fxval_fast& );
    friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, int ); friend const sc_fxval_fast operator + ( int, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, unsigned int ); friend const sc_fxval_fast operator + ( unsigned int, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, long ); friend const sc_fxval_fast operator + ( long, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, unsigned long ); friend const sc_fxval_fast operator + ( unsigned long, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, double ); friend const sc_fxval_fast operator + ( double, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const char* ); friend const sc_fxval_fast operator + ( const char*, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, int64 ); friend const sc_fxval_fast operator + ( int64, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, uint64 ); friend const sc_fxval_fast operator + ( uint64, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_int_base& ); friend const sc_fxval_fast operator + ( const sc_int_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator + ( const sc_uint_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_signed& ); friend const sc_fxval_fast operator + ( const sc_signed&, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator + ( const sc_unsigned&, const sc_fxval_fast& );
    friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, int ); friend const sc_fxval_fast operator - ( int, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, unsigned int ); friend const sc_fxval_fast operator - ( unsigned int, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, long ); friend const sc_fxval_fast operator - ( long, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, unsigned long ); friend const sc_fxval_fast operator - ( unsigned long, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, double ); friend const sc_fxval_fast operator - ( double, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const char* ); friend const sc_fxval_fast operator - ( const char*, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, int64 ); friend const sc_fxval_fast operator - ( int64, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, uint64 ); friend const sc_fxval_fast operator - ( uint64, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_int_base& ); friend const sc_fxval_fast operator - ( const sc_int_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator - ( const sc_uint_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_signed& ); friend const sc_fxval_fast operator - ( const sc_signed&, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator - ( const sc_unsigned&, const sc_fxval_fast& );


    friend const sc_fxval_fast operator / ( const sc_fxval_fast&,
          const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, int ); friend const sc_fxval_fast operator / ( int, const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, unsigned int ); friend const sc_fxval_fast operator / ( unsigned int, const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, long ); friend const sc_fxval_fast operator / ( long, const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, unsigned long ); friend const sc_fxval_fast operator / ( unsigned long, const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, double ); friend const sc_fxval_fast operator / ( double, const sc_fxval_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const char* ); friend const sc_fxval_fast operator / ( const char*, const sc_fxval_fast& );


    friend const sc_fxval_fast operator / ( const sc_fxval_fast&, int64 ); friend const sc_fxval_fast operator / ( int64, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, uint64 ); friend const sc_fxval_fast operator / ( uint64, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const sc_int_base& ); friend const sc_fxval_fast operator / ( const sc_int_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator / ( const sc_uint_base&, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const sc_signed& ); friend const sc_fxval_fast operator / ( const sc_signed&, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator / ( const sc_unsigned&, const sc_fxval_fast& );
# 541 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend const sc_fxval_fast operator << ( const sc_fxval_fast&, int );
    friend const sc_fxval_fast operator >> ( const sc_fxval_fast&, int );
# 576 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, int ); friend void mult ( sc_fxval_fast&, int, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, unsigned int ); friend void mult ( sc_fxval_fast&, unsigned int, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, long ); friend void mult ( sc_fxval_fast&, long, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, unsigned long ); friend void mult ( sc_fxval_fast&, unsigned long, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, double ); friend void mult ( sc_fxval_fast&, double, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const char* ); friend void mult ( sc_fxval_fast&, const char*, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval& ); friend void mult ( sc_fxval_fast&, const sc_fxval&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum& ); friend void mult ( sc_fxval_fast&, const sc_fxnum&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, int64 ); friend void mult ( sc_fxval_fast&, int64, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, uint64 ); friend void mult ( sc_fxval_fast&, uint64, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_int_base& ); friend void mult ( sc_fxval_fast&, const sc_int_base&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_uint_base& ); friend void mult ( sc_fxval_fast&, const sc_uint_base&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_signed& ); friend void mult ( sc_fxval_fast&, const sc_signed&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_unsigned& ); friend void mult ( sc_fxval_fast&, const sc_unsigned&, const sc_fxval_fast& );
    friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, int ); friend void div ( sc_fxval_fast&, int, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, unsigned int ); friend void div ( sc_fxval_fast&, unsigned int, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, long ); friend void div ( sc_fxval_fast&, long, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, unsigned long ); friend void div ( sc_fxval_fast&, unsigned long, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, double ); friend void div ( sc_fxval_fast&, double, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const char* ); friend void div ( sc_fxval_fast&, const char*, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval& ); friend void div ( sc_fxval_fast&, const sc_fxval&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum& ); friend void div ( sc_fxval_fast&, const sc_fxnum&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, int64 ); friend void div ( sc_fxval_fast&, int64, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, uint64 ); friend void div ( sc_fxval_fast&, uint64, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_int_base& ); friend void div ( sc_fxval_fast&, const sc_int_base&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_uint_base& ); friend void div ( sc_fxval_fast&, const sc_uint_base&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_signed& ); friend void div ( sc_fxval_fast&, const sc_signed&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_unsigned& ); friend void div ( sc_fxval_fast&, const sc_unsigned&, const sc_fxval_fast& );
    friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, int ); friend void add ( sc_fxval_fast&, int, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, unsigned int ); friend void add ( sc_fxval_fast&, unsigned int, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, long ); friend void add ( sc_fxval_fast&, long, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, unsigned long ); friend void add ( sc_fxval_fast&, unsigned long, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, double ); friend void add ( sc_fxval_fast&, double, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const char* ); friend void add ( sc_fxval_fast&, const char*, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval& ); friend void add ( sc_fxval_fast&, const sc_fxval&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum& ); friend void add ( sc_fxval_fast&, const sc_fxnum&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, int64 ); friend void add ( sc_fxval_fast&, int64, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, uint64 ); friend void add ( sc_fxval_fast&, uint64, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_int_base& ); friend void add ( sc_fxval_fast&, const sc_int_base&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_uint_base& ); friend void add ( sc_fxval_fast&, const sc_uint_base&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_signed& ); friend void add ( sc_fxval_fast&, const sc_signed&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_unsigned& ); friend void add ( sc_fxval_fast&, const sc_unsigned&, const sc_fxval_fast& );
    friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, int ); friend void sub ( sc_fxval_fast&, int, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, unsigned int ); friend void sub ( sc_fxval_fast&, unsigned int, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, long ); friend void sub ( sc_fxval_fast&, long, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, unsigned long ); friend void sub ( sc_fxval_fast&, unsigned long, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, double ); friend void sub ( sc_fxval_fast&, double, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const char* ); friend void sub ( sc_fxval_fast&, const char*, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxval& ); friend void sub ( sc_fxval_fast&, const sc_fxval&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum& ); friend void sub ( sc_fxval_fast&, const sc_fxnum&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, int64 ); friend void sub ( sc_fxval_fast&, int64, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, uint64 ); friend void sub ( sc_fxval_fast&, uint64, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_int_base& ); friend void sub ( sc_fxval_fast&, const sc_int_base&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_uint_base& ); friend void sub ( sc_fxval_fast&, const sc_uint_base&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_signed& ); friend void sub ( sc_fxval_fast&, const sc_signed&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_unsigned& ); friend void sub ( sc_fxval_fast&, const sc_unsigned&, const sc_fxval_fast& );





    friend void lshift( sc_fxval_fast&, const sc_fxval_fast&, int );
    friend void rshift( sc_fxval_fast&, const sc_fxval_fast&, int );
# 617 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    friend bool operator < ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, int ); friend bool operator < ( int, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, unsigned int ); friend bool operator < ( unsigned int, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, long ); friend bool operator < ( long, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, unsigned long ); friend bool operator < ( unsigned long, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, double ); friend bool operator < ( double, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const char* ); friend bool operator < ( const char*, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, int64 ); friend bool operator < ( int64, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, uint64 ); friend bool operator < ( uint64, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator < ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator < ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_signed& ); friend bool operator < ( const sc_signed&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator < ( const sc_unsigned&, const sc_fxval_fast& );
    friend bool operator <= ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, int ); friend bool operator <= ( int, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, unsigned int ); friend bool operator <= ( unsigned int, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, long ); friend bool operator <= ( long, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, unsigned long ); friend bool operator <= ( unsigned long, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, double ); friend bool operator <= ( double, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const char* ); friend bool operator <= ( const char*, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, int64 ); friend bool operator <= ( int64, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, uint64 ); friend bool operator <= ( uint64, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator <= ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator <= ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_signed& ); friend bool operator <= ( const sc_signed&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator <= ( const sc_unsigned&, const sc_fxval_fast& );
    friend bool operator > ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, int ); friend bool operator > ( int, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, unsigned int ); friend bool operator > ( unsigned int, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, long ); friend bool operator > ( long, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, unsigned long ); friend bool operator > ( unsigned long, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, double ); friend bool operator > ( double, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const char* ); friend bool operator > ( const char*, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, int64 ); friend bool operator > ( int64, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, uint64 ); friend bool operator > ( uint64, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator > ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator > ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_signed& ); friend bool operator > ( const sc_signed&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator > ( const sc_unsigned&, const sc_fxval_fast& );
    friend bool operator >= ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, int ); friend bool operator >= ( int, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, unsigned int ); friend bool operator >= ( unsigned int, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, long ); friend bool operator >= ( long, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, unsigned long ); friend bool operator >= ( unsigned long, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, double ); friend bool operator >= ( double, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const char* ); friend bool operator >= ( const char*, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, int64 ); friend bool operator >= ( int64, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, uint64 ); friend bool operator >= ( uint64, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator >= ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator >= ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_signed& ); friend bool operator >= ( const sc_signed&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator >= ( const sc_unsigned&, const sc_fxval_fast& );
    friend bool operator == ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, int ); friend bool operator == ( int, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, long ); friend bool operator == ( long, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, double ); friend bool operator == ( double, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const char* ); friend bool operator == ( const char*, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, int64 ); friend bool operator == ( int64, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, uint64 ); friend bool operator == ( uint64, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator == ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator == ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxval_fast& );
    friend bool operator != ( const sc_fxval_fast&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, int ); friend bool operator != ( int, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, long ); friend bool operator != ( long, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, double ); friend bool operator != ( double, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const char* ); friend bool operator != ( const char*, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, int64 ); friend bool operator != ( int64, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, uint64 ); friend bool operator != ( uint64, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_int_base& ); friend bool operator != ( const sc_int_base&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_uint_base& ); friend bool operator != ( const sc_uint_base&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxval_fast& );
# 659 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    sc_fxval_fast& operator =( int ); sc_fxval_fast& operator =( unsigned int ); sc_fxval_fast& operator =( long ); sc_fxval_fast& operator =( unsigned long ); sc_fxval_fast& operator =( double ); sc_fxval_fast& operator =( const char* ); sc_fxval_fast& operator =( const sc_fxval& ); sc_fxval_fast& operator =( const sc_fxval_fast& ); sc_fxval_fast& operator =( const sc_fxnum& ); sc_fxval_fast& operator =( const sc_fxnum_fast& ); sc_fxval_fast& operator =( int64 ); sc_fxval_fast& operator =( uint64 ); sc_fxval_fast& operator =( const sc_int_base& ); sc_fxval_fast& operator =( const sc_uint_base& ); sc_fxval_fast& operator =( const sc_signed& ); sc_fxval_fast& operator =( const sc_unsigned& );

    sc_fxval_fast& operator *=( int ); sc_fxval_fast& operator *=( unsigned int ); sc_fxval_fast& operator *=( long ); sc_fxval_fast& operator *=( unsigned long ); sc_fxval_fast& operator *=( double ); sc_fxval_fast& operator *=( const char* ); sc_fxval_fast& operator *=( const sc_fxval& ); sc_fxval_fast& operator *=( const sc_fxval_fast& ); sc_fxval_fast& operator *=( const sc_fxnum& ); sc_fxval_fast& operator *=( const sc_fxnum_fast& ); sc_fxval_fast& operator *=( int64 ); sc_fxval_fast& operator *=( uint64 ); sc_fxval_fast& operator *=( const sc_int_base& ); sc_fxval_fast& operator *=( const sc_uint_base& ); sc_fxval_fast& operator *=( const sc_signed& ); sc_fxval_fast& operator *=( const sc_unsigned& );
    sc_fxval_fast& operator /=( int ); sc_fxval_fast& operator /=( unsigned int ); sc_fxval_fast& operator /=( long ); sc_fxval_fast& operator /=( unsigned long ); sc_fxval_fast& operator /=( double ); sc_fxval_fast& operator /=( const char* ); sc_fxval_fast& operator /=( const sc_fxval& ); sc_fxval_fast& operator /=( const sc_fxval_fast& ); sc_fxval_fast& operator /=( const sc_fxnum& ); sc_fxval_fast& operator /=( const sc_fxnum_fast& ); sc_fxval_fast& operator /=( int64 ); sc_fxval_fast& operator /=( uint64 ); sc_fxval_fast& operator /=( const sc_int_base& ); sc_fxval_fast& operator /=( const sc_uint_base& ); sc_fxval_fast& operator /=( const sc_signed& ); sc_fxval_fast& operator /=( const sc_unsigned& );
    sc_fxval_fast& operator +=( int ); sc_fxval_fast& operator +=( unsigned int ); sc_fxval_fast& operator +=( long ); sc_fxval_fast& operator +=( unsigned long ); sc_fxval_fast& operator +=( double ); sc_fxval_fast& operator +=( const char* ); sc_fxval_fast& operator +=( const sc_fxval& ); sc_fxval_fast& operator +=( const sc_fxval_fast& ); sc_fxval_fast& operator +=( const sc_fxnum& ); sc_fxval_fast& operator +=( const sc_fxnum_fast& ); sc_fxval_fast& operator +=( int64 ); sc_fxval_fast& operator +=( uint64 ); sc_fxval_fast& operator +=( const sc_int_base& ); sc_fxval_fast& operator +=( const sc_uint_base& ); sc_fxval_fast& operator +=( const sc_signed& ); sc_fxval_fast& operator +=( const sc_unsigned& );
    sc_fxval_fast& operator -=( int ); sc_fxval_fast& operator -=( unsigned int ); sc_fxval_fast& operator -=( long ); sc_fxval_fast& operator -=( unsigned long ); sc_fxval_fast& operator -=( double ); sc_fxval_fast& operator -=( const char* ); sc_fxval_fast& operator -=( const sc_fxval& ); sc_fxval_fast& operator -=( const sc_fxval_fast& ); sc_fxval_fast& operator -=( const sc_fxnum& ); sc_fxval_fast& operator -=( const sc_fxnum_fast& ); sc_fxval_fast& operator -=( int64 ); sc_fxval_fast& operator -=( uint64 ); sc_fxval_fast& operator -=( const sc_int_base& ); sc_fxval_fast& operator -=( const sc_uint_base& ); sc_fxval_fast& operator -=( const sc_signed& ); sc_fxval_fast& operator -=( const sc_unsigned& );

    sc_fxval_fast& operator <<=( int );
    sc_fxval_fast& operator >>=( int );
# 676 "../../../src/systemc/datatypes/fx/sc_fxval.h"
    const sc_fxval_fast operator ++ ( int );
    const sc_fxval_fast operator -- ( int );

    sc_fxval_fast& operator ++ ();
    sc_fxval_fast& operator -- ();




    operator double() const;




    short to_short() const;
    unsigned short to_ushort() const;
    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    float to_float() const;
    double to_double() const;




    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;
    const sc_string to_string( sc_fmt ) const;
    const sc_string to_string( sc_numrep, sc_fmt ) const;
    const sc_string to_string( sc_numrep, bool, sc_fmt ) const;

    const sc_string to_dec() const;
    const sc_string to_bin() const;
    const sc_string to_oct() const;
    const sc_string to_hex() const;




    bool is_neg() const;
    bool is_zero() const;
    bool is_nan() const;
    bool is_inf() const;
    bool is_normal() const;

    bool rounding_flag() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;



    bool get_bit( int ) const;

protected:

    sc_fxval_fast_observer* lock_observer() const;
    void unlock_observer( sc_fxval_fast_observer* ) const;


    static double from_string( const char* );

private:

    double m_val;

    mutable sc_fxval_fast_observer* m_observer;

};
# 763 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval_observer*
sc_fxval::observer() const
{
    return m_observer;
}



inline
sc_fxval::sc_fxval( scfx_rep* a )
: m_rep( a ),
  m_observer( 0 )
{}




inline
sc_fxval::sc_fxval( sc_fxval_observer* observer_ )
: m_rep( new scfx_rep ),
  m_observer( observer_ )
{
   
   
}

inline
sc_fxval::sc_fxval( const sc_fxval& a,
      sc_fxval_observer* observer_ )
: m_rep( new scfx_rep( *a.m_rep ) ),
  m_observer( observer_ )
{
   
   
   
   
}
# 818 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval::sc_fxval( int a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( unsigned int a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( long a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( unsigned long a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( double a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const char* a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const sc_fxval_fast& a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a.to_double() ) ), m_observer( observer_ ) { }

inline sc_fxval::sc_fxval( int64 a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( uint64 a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const sc_int_base& a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a.value() ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const sc_uint_base& a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a.value() ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const sc_signed& a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
inline sc_fxval::sc_fxval( const sc_unsigned& a, sc_fxval_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_observer( observer_ ) { }
# 840 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval::~sc_fxval()
{
   
    delete m_rep;
}



inline
const scfx_rep*
sc_fxval::get_rep() const
{
   
    return m_rep;
}


inline
void
sc_fxval::set_rep( scfx_rep* rep_ )
{
    delete m_rep;
    m_rep = rep_;
   
}




inline
const sc_fxval
sc_fxval::operator - () const
{
   
    return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
}

inline
const sc_fxval&
sc_fxval::operator + () const
{

    return *this;
}




inline
void
neg( sc_fxval& c, const sc_fxval& a )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
   
}
# 952 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline const sc_fxval operator * ( const sc_fxval& a, const sc_fxval& b ) { return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator + ( const sc_fxval& a, const sc_fxval& b ) { return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator - ( const sc_fxval& a, const sc_fxval& b ) { return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }


inline
const sc_fxval
operator / ( const sc_fxval& a, const sc_fxval& b )
{
   
   
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
}

inline const sc_fxval operator / ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }


inline const sc_fxval operator / ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
# 988 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
const sc_fxval
operator << ( const sc_fxval& a, int b )
{
   
    return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
}

inline
const sc_fxval
operator >> ( const sc_fxval& a, int b )
{
   
    return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
}
# 1063 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline void mult( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, double a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void div( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, double a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void add( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, double a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void sub( sc_fxval& c, const sc_fxval& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, double a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); }






inline
void
lshift( sc_fxval& c, const sc_fxval& a, int b )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
   
}

inline
void
rshift( sc_fxval& c, const sc_fxval& a, int b )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
   
}
# 1149 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline bool operator < ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); }
inline bool operator <= ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); }
inline bool operator > ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); }
inline bool operator >= ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); }
inline bool operator == ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); }
inline bool operator != ( const sc_fxval& a, const sc_fxval& b) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( unsigned int a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( unsigned long a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( double a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const char* a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( int64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( uint64 a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_int_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_uint_base& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_signed& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_unsigned& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); }
# 1163 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval&
sc_fxval::operator = ( const sc_fxval& a )
{
    if( &a != this )
    {

 *m_rep = *a.m_rep;

    }
    return *this;
}
# 1187 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval& sc_fxval::operator = ( int b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( unsigned int b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( long b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( unsigned long b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( double b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const char* b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }

inline sc_fxval& sc_fxval::operator = ( int64 b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( uint64 b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const sc_int_base& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const sc_uint_base& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const sc_signed& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
inline sc_fxval& sc_fxval::operator = ( const sc_unsigned& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
# 1255 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval& sc_fxval::operator *= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator /= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator += ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator -= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }






inline
sc_fxval&
sc_fxval::operator <<= ( int b )
{
   
    m_rep->lshift( b );
   
    return *this;
}

inline
sc_fxval&
sc_fxval::operator >>= ( int b )
{
   
    m_rep->rshift( b );
   
    return *this;
}




inline
const sc_fxval
sc_fxval::operator ++ ( int )
{
    sc_fxval c = *this;
    (*this) += 1;
    return c;
}

inline
const sc_fxval
sc_fxval::operator -- ( int )
{
    sc_fxval c = *this;
    (*this) -= 1;
    return c;
}

inline
sc_fxval&
sc_fxval::operator ++ ()
{
    (*this) += 1;
    return *this;
}

inline
sc_fxval&
sc_fxval::operator -- ()
{
    (*this) -= 1;
    return *this;
}




inline
sc_fxval::operator double() const
{
   
    return m_rep->to_double();
}




inline
short
sc_fxval::to_short() const
{
   
    return static_cast<short>( m_rep->to_double() );
}

inline
unsigned short
sc_fxval::to_ushort() const
{
   
    return static_cast<unsigned short>( m_rep->to_double() );
}

inline
int
sc_fxval::to_int() const
{
   
    return static_cast<int>( m_rep->to_double() );
}

inline
unsigned int
sc_fxval::to_uint() const
{
   
    return static_cast<unsigned int>( m_rep->to_double() );
}

inline
long
sc_fxval::to_long() const
{
   
    return static_cast<long>( m_rep->to_double() );
}

inline
unsigned long
sc_fxval::to_ulong() const
{
   
    return static_cast<unsigned long>( m_rep->to_double() );
}

inline
float
sc_fxval::to_float() const
{
   
    return static_cast<float>( m_rep->to_double() );
}

inline
double
sc_fxval::to_double() const
{
   
    return m_rep->to_double();
}




inline
bool
sc_fxval::is_neg() const
{
   
    return m_rep->is_neg();
}

inline
bool
sc_fxval::is_zero() const
{
   
    return m_rep->is_zero();
}

inline
bool
sc_fxval::is_nan() const
{
   
    return m_rep->is_nan();
}

inline
bool
sc_fxval::is_inf() const
{
   
    return m_rep->is_inf();
}

inline
bool
sc_fxval::is_normal() const
{
   
    return m_rep->is_normal();
}


inline
bool
sc_fxval::rounding_flag() const
{
    return m_rep->rounding_flag();
}



inline
bool
sc_fxval::get_bit( int i ) const
{
    return m_rep->get_bit( i );
}




inline
void
sc_fxval::get_type( int& wl, int& iwl, sc_enc& enc ) const
{
    m_rep->get_type( wl, iwl, enc );
}


inline
const sc_fxval
sc_fxval::quantization( const scfx_params& params, bool& q_flag ) const
{
    return sc_fxval( sc_dt::quantization_scfx_rep( *m_rep, params, q_flag ) );
}

inline
const sc_fxval
sc_fxval::overflow( const scfx_params& params, bool& o_flag ) const
{
    return sc_fxval( sc_dt::overflow_scfx_rep( *m_rep, params, o_flag ) );
}


inline
ostream&
operator << ( ostream& os, const sc_fxval& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxval& a )
{
    a.scan( is );
    return is;
}
# 1510 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval_fast_observer*
sc_fxval_fast::observer() const
{
    return m_observer;
}




inline
sc_fxval_fast::sc_fxval_fast( sc_fxval_fast_observer* observer_ )
: m_val( 0.0 ),
  m_observer( observer_ )
{
   
   
}

inline
sc_fxval_fast::sc_fxval_fast( const sc_fxval_fast& a,
         sc_fxval_fast_observer* observer_ )
: m_val( a.m_val ),
  m_observer( observer_ )
{
   
   
   
   
}
# 1557 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval_fast::sc_fxval_fast( int a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( unsigned int a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( long a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( unsigned long a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( double a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const char* a, sc_fxval_fast_observer* observer_ ) : m_val( from_string( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const sc_fxval& a, sc_fxval_fast_observer* observer_ ) : m_val( a.to_double() ), m_observer( observer_ ) { }

inline sc_fxval_fast::sc_fxval_fast( int64 a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( uint64 a, sc_fxval_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const sc_int_base& a, sc_fxval_fast_observer* observer_ ) : m_val( a.to_double() ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const sc_uint_base& a, sc_fxval_fast_observer* observer_ ) : m_val( a.to_double() ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const sc_signed& a, sc_fxval_fast_observer* observer_ ) : m_val( a.to_double() ), m_observer( observer_ ) { }
inline sc_fxval_fast::sc_fxval_fast( const sc_unsigned& a, sc_fxval_fast_observer* observer_ ) : m_val( a.to_double() ), m_observer( observer_ ) { }
# 1581 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval_fast::~sc_fxval_fast()
{
   
}



inline
double
sc_fxval_fast::get_val() const
{
   
    return m_val;
}


inline
void
sc_fxval_fast::set_val( double val_ )
{
    m_val = val_;
   
}




inline
const sc_fxval_fast
sc_fxval_fast::operator - () const
{
   
    return sc_fxval_fast( - m_val );
}

inline
const sc_fxval_fast&
sc_fxval_fast::operator + () const
{

    return *this;
}




inline
void
neg( sc_fxval_fast& c, const sc_fxval_fast& a )
{
   
    c.m_val = - a.m_val;
   
}
# 1689 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.m_val ); } inline const sc_fxval_fast operator * ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val * b.m_val ); }
inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.m_val ); } inline const sc_fxval_fast operator + ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val + b.m_val ); }
inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.m_val ); } inline const sc_fxval_fast operator - ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val - b.m_val ); }

inline
const sc_fxval_fast
operator / ( const sc_fxval_fast& a, const sc_fxval_fast& b )
{
   
   
    return sc_fxval_fast( a.m_val / b.m_val );
}

inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }


inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.m_val ); } inline const sc_fxval_fast operator / ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.m_val / b.m_val ); }
# 1724 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
const sc_fxval_fast
operator << ( const sc_fxval_fast& a, int b )
{
   
    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
}

inline
const sc_fxval_fast
operator >> ( const sc_fxval_fast& a, int b )
{
   
    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
}
# 1795 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; }
inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; }
inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; }
inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; }






inline
void
lshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
{
   
    c.m_val = a.m_val * scfx_pow2( b );
   
}

inline
void
rshift( sc_fxval_fast& c, const sc_fxval_fast& a, int b )
{
   
    c.m_val = a.m_val * scfx_pow2( -b );
   
}
# 1875 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline bool operator < ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); } inline bool operator < ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.m_val ); } inline bool operator < ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val < b.m_val ); }
inline bool operator <= ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.m_val ); } inline bool operator <= ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val <= b.m_val ); }
inline bool operator > ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); } inline bool operator > ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.m_val ); } inline bool operator > ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val > b.m_val ); }
inline bool operator >= ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.m_val ); } inline bool operator >= ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val >= b.m_val ); }
inline bool operator == ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); } inline bool operator == ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.m_val ); } inline bool operator == ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val == b.m_val ); }
inline bool operator != ( const sc_fxval_fast& a, const sc_fxval_fast& b ) { return ( a.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( unsigned int a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( unsigned long a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( double a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( const char* a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( int64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( uint64 a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( const sc_int_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( const sc_uint_base& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( const sc_signed& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); } inline bool operator != ( const sc_fxval_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.m_val ); } inline bool operator != ( const sc_unsigned& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.m_val != b.m_val ); }
# 1889 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline
sc_fxval_fast&
sc_fxval_fast::operator = ( const sc_fxval_fast& a )
{
    if( &a != this )
    {

 m_val = a.m_val;

    }
    return *this;
}
# 1913 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval_fast& sc_fxval_fast::operator = ( int a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( unsigned int a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( long a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( unsigned long a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( double a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const char* a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_fxval& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }

inline sc_fxval_fast& sc_fxval_fast::operator = ( int64 a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( uint64 a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_int_base& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_uint_base& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_signed& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_unsigned& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
# 1977 "../../../src/systemc/datatypes/fx/sc_fxval.h"
inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_fxval_fast& b ) { m_val *= b.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( int b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( long b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( double b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const char* b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( int64 b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_fxval_fast& b ) { m_val /= b.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( int b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( long b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( double b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const char* b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( int64 b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_fxval_fast& b ) { m_val += b.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( int b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( long b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( double b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const char* b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( int64 b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( uint64 b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_fxval_fast& b ) { m_val -= b.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( int b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( long b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( double b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const char* b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( int64 b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; }






inline
sc_fxval_fast&
sc_fxval_fast::operator <<= ( int b )
{
   
    m_val *= scfx_pow2( b );
   
    return *this;
}

inline
sc_fxval_fast&
sc_fxval_fast::operator >>= ( int b )
{
   
    m_val *= scfx_pow2( -b );
   
    return *this;
}




inline
const sc_fxval_fast
sc_fxval_fast::operator ++ ( int )
{
   
   
    double c = m_val;
    m_val = m_val + 1;
   
    return sc_fxval_fast( c );
}

inline
const sc_fxval_fast
sc_fxval_fast::operator -- ( int )
{
   
   
    double c = m_val;
    m_val = m_val - 1;
   
    return sc_fxval_fast( c );
}

inline
sc_fxval_fast&
sc_fxval_fast::operator ++ ()
{
   
    m_val = m_val + 1;
   
    return *this;
}

inline
sc_fxval_fast&
sc_fxval_fast::operator -- ()
{
   
    m_val = m_val - 1;
   
    return *this;
}




inline
sc_fxval_fast::operator double() const
{
   
    return m_val;
}




inline
short
sc_fxval_fast::to_short() const
{
   
    return static_cast<short>( m_val );
}

inline
unsigned short
sc_fxval_fast::to_ushort() const
{
   
    return static_cast<unsigned short>( m_val );
}

inline
int
sc_fxval_fast::to_int() const
{
   
    return static_cast<int>( m_val );
}

inline
unsigned int
sc_fxval_fast::to_uint() const
{
   
    return static_cast<unsigned int>( m_val );
}

inline
long
sc_fxval_fast::to_long() const
{
   
    return static_cast<long>( m_val );
}

inline
unsigned long
sc_fxval_fast::to_ulong() const
{
   
    return static_cast<unsigned long>( m_val );
}

inline
float
sc_fxval_fast::to_float() const
{
   
    return static_cast<float>( m_val );
}

inline
double
sc_fxval_fast::to_double() const
{
   
    return m_val;
}




inline
bool
sc_fxval_fast::is_neg() const
{
   
    scfx_ieee_double id( m_val );
    return ( id.negative() != 0 );
}

inline
bool
sc_fxval_fast::is_zero() const
{
   
    scfx_ieee_double id( m_val );
    return id.is_zero();
}

inline
bool
sc_fxval_fast::is_nan() const
{
   
    scfx_ieee_double id( m_val );
    return id.is_nan();
}

inline
bool
sc_fxval_fast::is_inf() const
{
   
    scfx_ieee_double id( m_val );
    return id.is_inf();
}

inline
bool
sc_fxval_fast::is_normal() const
{
   
    scfx_ieee_double id( m_val );
    return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
}


inline
bool
sc_fxval_fast::rounding_flag() const
{

    return false;
}


inline
ostream&
operator << ( ostream& os, const sc_fxval_fast& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxval_fast& a )
{
    a.scan( is );
    return is;
}

}
# 42 "../../../src/systemc/datatypes/fx/sc_fxnum.h" 2

# 1 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h" 1
# 43 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h"
namespace sc_dt
{


class sc_fxnum_observer;
class sc_fxnum_fast_observer;


class sc_fxnum;
class sc_fxnum_fast;
# 102 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h"
class sc_fxnum_observer
{

protected:

    sc_fxnum_observer() {}
    virtual ~sc_fxnum_observer() {}

public:

    virtual void construct( const sc_fxnum& );
    virtual void destruct( const sc_fxnum& );
    virtual void read( const sc_fxnum& );
    virtual void write( const sc_fxnum& );

    static sc_fxnum_observer* (*default_observer) ();

};
# 128 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h"
class sc_fxnum_fast_observer
{

protected:

    sc_fxnum_fast_observer() {}
    virtual ~sc_fxnum_fast_observer() {}

public:

    virtual void construct( const sc_fxnum_fast& );
    virtual void destruct( const sc_fxnum_fast& );
    virtual void read( const sc_fxnum_fast& );
    virtual void write( const sc_fxnum_fast& );

    static sc_fxnum_fast_observer* (*default_observer) ();

};
# 156 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h"
inline
void
sc_fxnum_observer::construct( const sc_fxnum& )
{}

inline
void
sc_fxnum_observer::destruct( const sc_fxnum& )
{}

inline
void
sc_fxnum_observer::read( const sc_fxnum& )
{}

inline
void
sc_fxnum_observer::write( const sc_fxnum& )
{}
# 183 "../../../src/systemc/datatypes/fx/sc_fxnum_observer.h"
inline
void
sc_fxnum_fast_observer::construct( const sc_fxnum_fast& )
{}

inline
void
sc_fxnum_fast_observer::destruct( const sc_fxnum_fast& )
{}

inline
void
sc_fxnum_fast_observer::read( const sc_fxnum_fast& )
{}

inline
void
sc_fxnum_fast_observer::write( const sc_fxnum_fast& )
{}

}
# 44 "../../../src/systemc/datatypes/fx/sc_fxnum.h" 2


class vcd_sc_fxnum_trace;
class vcd_sc_fxnum_fast_trace;
class wif_sc_fxnum_trace;
class wif_sc_fxnum_fast_trace;


namespace sc_dt
{


class sc_fxnum_bitref;
class sc_fxnum_fast_bitref;
class sc_fxnum_subref;
class sc_fxnum_fast_subref;
class sc_fxnum;
class sc_fxnum_fast;
# 70 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum_bitref
{
    friend class sc_fxnum;
    friend class sc_fxnum_fast_bitref;


    bool get() const;
    void set( bool );




    sc_fxnum_bitref( sc_fxnum&, int );

public:



    sc_fxnum_bitref( const sc_fxnum_bitref& );
# 102 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_bitref& operator = ( const sc_fxnum_bitref& ); sc_fxnum_bitref& operator = ( const sc_fxnum_fast_bitref& ); sc_fxnum_bitref& operator = ( const sc_bit& ); sc_fxnum_bitref& operator = ( bool );

    sc_fxnum_bitref& operator &= ( const sc_fxnum_bitref& ); sc_fxnum_bitref& operator &= ( const sc_fxnum_fast_bitref& ); sc_fxnum_bitref& operator &= ( const sc_bit& ); sc_fxnum_bitref& operator &= ( bool );
    sc_fxnum_bitref& operator |= ( const sc_fxnum_bitref& ); sc_fxnum_bitref& operator |= ( const sc_fxnum_fast_bitref& ); sc_fxnum_bitref& operator |= ( const sc_bit& ); sc_fxnum_bitref& operator |= ( bool );
    sc_fxnum_bitref& operator ^= ( const sc_fxnum_bitref& ); sc_fxnum_bitref& operator ^= ( const sc_fxnum_fast_bitref& ); sc_fxnum_bitref& operator ^= ( const sc_bit& ); sc_fxnum_bitref& operator ^= ( bool );







    operator bool() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;

private:

    sc_fxnum& m_num;
    int m_idx;

private:


    sc_fxnum_bitref();
};
# 141 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum_fast_bitref
{
    friend class sc_fxnum_fast;
    friend class sc_fxnum_bitref;


    bool get() const;
    void set( bool );




    sc_fxnum_fast_bitref( sc_fxnum_fast&, int );

public:



    sc_fxnum_fast_bitref( const sc_fxnum_fast_bitref& );
# 173 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_fast_bitref& operator = ( const sc_fxnum_bitref& ); sc_fxnum_fast_bitref& operator = ( const sc_fxnum_fast_bitref& ); sc_fxnum_fast_bitref& operator = ( const sc_bit& ); sc_fxnum_fast_bitref& operator = ( bool );

    sc_fxnum_fast_bitref& operator &= ( const sc_fxnum_bitref& ); sc_fxnum_fast_bitref& operator &= ( const sc_fxnum_fast_bitref& ); sc_fxnum_fast_bitref& operator &= ( const sc_bit& ); sc_fxnum_fast_bitref& operator &= ( bool );
    sc_fxnum_fast_bitref& operator |= ( const sc_fxnum_bitref& ); sc_fxnum_fast_bitref& operator |= ( const sc_fxnum_fast_bitref& ); sc_fxnum_fast_bitref& operator |= ( const sc_bit& ); sc_fxnum_fast_bitref& operator |= ( bool );
    sc_fxnum_fast_bitref& operator ^= ( const sc_fxnum_bitref& ); sc_fxnum_fast_bitref& operator ^= ( const sc_fxnum_fast_bitref& ); sc_fxnum_fast_bitref& operator ^= ( const sc_bit& ); sc_fxnum_fast_bitref& operator ^= ( bool );







    operator bool() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;

private:

    sc_fxnum_fast& m_num;
    int m_idx;

private:


    sc_fxnum_fast_bitref();
};
# 213 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum_subref
{
    friend class sc_fxnum;
    friend class sc_fxnum_fast_subref;

    bool get() const;
    bool set();




    sc_fxnum_subref( sc_fxnum&, int, int );

public:



    sc_fxnum_subref( const sc_fxnum_subref& );




    ~sc_fxnum_subref();







    sc_fxnum_subref& operator = ( const sc_fxnum_subref& );
    sc_fxnum_subref& operator = ( const sc_fxnum_fast_subref& );
    sc_fxnum_subref& operator = ( const sc_bv_base& );
    sc_fxnum_subref& operator = ( const sc_lv_base& );
    sc_fxnum_subref& operator = ( const char* );
    sc_fxnum_subref& operator = ( const bool* );
    sc_fxnum_subref& operator = ( const sc_signed& );
    sc_fxnum_subref& operator = ( const sc_unsigned& );
    sc_fxnum_subref& operator = ( const sc_int_base& );
    sc_fxnum_subref& operator = ( const sc_uint_base& );
    sc_fxnum_subref& operator = ( int64 );
    sc_fxnum_subref& operator = ( uint64 );
    sc_fxnum_subref& operator = ( int );
    sc_fxnum_subref& operator = ( unsigned int );
    sc_fxnum_subref& operator = ( long );
    sc_fxnum_subref& operator = ( unsigned long );
    sc_fxnum_subref& operator = ( char );
# 272 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_subref& operator &= ( const sc_fxnum_subref& ); sc_fxnum_subref& operator &= ( const sc_fxnum_fast_subref& ); sc_fxnum_subref& operator &= ( const sc_bv_base& ); sc_fxnum_subref& operator &= ( const sc_lv_base& );
    sc_fxnum_subref& operator |= ( const sc_fxnum_subref& ); sc_fxnum_subref& operator |= ( const sc_fxnum_fast_subref& ); sc_fxnum_subref& operator |= ( const sc_bv_base& ); sc_fxnum_subref& operator |= ( const sc_lv_base& );
    sc_fxnum_subref& operator ^= ( const sc_fxnum_subref& ); sc_fxnum_subref& operator ^= ( const sc_fxnum_fast_subref& ); sc_fxnum_subref& operator ^= ( const sc_bv_base& ); sc_fxnum_subref& operator ^= ( const sc_lv_base& );
# 302 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend bool operator == ( const sc_fxnum_subref&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_subref&, const sc_bv_base& ); friend bool operator == ( const sc_bv_base&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const sc_lv_base& ); friend bool operator == ( const sc_lv_base&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const char* ); friend bool operator == ( const char*, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const bool* ); friend bool operator == ( const bool*, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, int ); friend bool operator == ( int, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, long ); friend bool operator == ( long, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_subref&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxnum_subref& );
    friend bool operator != ( const sc_fxnum_subref&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_subref&, const sc_bv_base& ); friend bool operator != ( const sc_bv_base&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const sc_lv_base& ); friend bool operator != ( const sc_lv_base&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const char* ); friend bool operator != ( const char*, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const bool* ); friend bool operator != ( const bool*, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, int ); friend bool operator != ( int, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, long ); friend bool operator != ( long, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_subref&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxnum_subref& );







    bool and_reduce() const;
    bool nand_reduce() const;
    bool or_reduce() const;
    bool nor_reduce() const;
    bool xor_reduce() const;
    bool xnor_reduce() const;




    int length() const;




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;






    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;




    operator sc_bv_base() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;

private:

    sc_fxnum& m_num;
    int m_from;
    int m_to;

    sc_bv_base& m_bv;

private:


    sc_fxnum_subref();
};
# 374 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum_fast_subref
{
    friend class sc_fxnum_fast;
    friend class sc_fxnum_subref;

    bool get() const;
    bool set();




    sc_fxnum_fast_subref( sc_fxnum_fast&, int, int );

public:



    sc_fxnum_fast_subref( const sc_fxnum_fast_subref& );




    ~sc_fxnum_fast_subref();







    sc_fxnum_fast_subref& operator = ( const sc_fxnum_subref& );
    sc_fxnum_fast_subref& operator = ( const sc_fxnum_fast_subref& );
    sc_fxnum_fast_subref& operator = ( const sc_bv_base& );
    sc_fxnum_fast_subref& operator = ( const sc_lv_base& );
    sc_fxnum_fast_subref& operator = ( const char* );
    sc_fxnum_fast_subref& operator = ( const bool* );
    sc_fxnum_fast_subref& operator = ( const sc_signed& );
    sc_fxnum_fast_subref& operator = ( const sc_unsigned& );
    sc_fxnum_fast_subref& operator = ( const sc_int_base& );
    sc_fxnum_fast_subref& operator = ( const sc_uint_base& );
    sc_fxnum_fast_subref& operator = ( int64 );
    sc_fxnum_fast_subref& operator = ( uint64 );
    sc_fxnum_fast_subref& operator = ( int );
    sc_fxnum_fast_subref& operator = ( unsigned int );
    sc_fxnum_fast_subref& operator = ( long );
    sc_fxnum_fast_subref& operator = ( unsigned long );
    sc_fxnum_fast_subref& operator = ( char );
# 433 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_fast_subref& operator &= ( const sc_fxnum_subref& ); sc_fxnum_fast_subref& operator &= ( const sc_fxnum_fast_subref& ); sc_fxnum_fast_subref& operator &= ( const sc_bv_base& ); sc_fxnum_fast_subref& operator &= ( const sc_lv_base& );
    sc_fxnum_fast_subref& operator |= ( const sc_fxnum_subref& ); sc_fxnum_fast_subref& operator |= ( const sc_fxnum_fast_subref& ); sc_fxnum_fast_subref& operator |= ( const sc_bv_base& ); sc_fxnum_fast_subref& operator |= ( const sc_lv_base& );
    sc_fxnum_fast_subref& operator ^= ( const sc_fxnum_subref& ); sc_fxnum_fast_subref& operator ^= ( const sc_fxnum_fast_subref& ); sc_fxnum_fast_subref& operator ^= ( const sc_bv_base& ); sc_fxnum_fast_subref& operator ^= ( const sc_lv_base& );
# 463 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend bool operator == ( const sc_fxnum_fast_subref&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const sc_fxnum_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const sc_bv_base& ); friend bool operator == ( const sc_bv_base&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const sc_lv_base& ); friend bool operator == ( const sc_lv_base&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const char* ); friend bool operator == ( const char*, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const bool* ); friend bool operator == ( const bool*, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, int ); friend bool operator == ( int, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, long ); friend bool operator == ( long, const sc_fxnum_fast_subref& ); friend bool operator == ( const sc_fxnum_fast_subref&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxnum_fast_subref& );
    friend bool operator != ( const sc_fxnum_fast_subref&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const sc_fxnum_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const sc_bv_base& ); friend bool operator != ( const sc_bv_base&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const sc_lv_base& ); friend bool operator != ( const sc_lv_base&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const char* ); friend bool operator != ( const char*, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const bool* ); friend bool operator != ( const bool*, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, int ); friend bool operator != ( int, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, long ); friend bool operator != ( long, const sc_fxnum_fast_subref& ); friend bool operator != ( const sc_fxnum_fast_subref&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxnum_fast_subref& );







    bool and_reduce() const;
    bool nand_reduce() const;
    bool or_reduce() const;
    bool nor_reduce() const;
    bool xor_reduce() const;
    bool xnor_reduce() const;




    int length() const;




    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;






    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;




    operator sc_bv_base() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;

private:

    sc_fxnum_fast& m_num;
    int m_from;
    int m_to;

    sc_bv_base& m_bv;

private:


    sc_fxnum_fast_subref();
};
# 534 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum
{
    friend class sc_fxval;

    friend class sc_fxnum_bitref;
    friend class sc_fxnum_subref;
    friend class sc_fxnum_fast_bitref;
    friend class sc_fxnum_fast_subref;

    friend class ::vcd_sc_fxnum_trace;
    friend class ::wif_sc_fxnum_trace;

protected:

    sc_fxnum_observer* observer() const;


    void cast();




    sc_fxnum( const sc_fxtype_params&,
       sc_enc,
       const sc_fxcast_switch&,
       sc_fxnum_observer* );
# 568 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum( int, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( unsigned int, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( long, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( unsigned long, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( double, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const char*, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_fxval&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_fxval_fast&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_fxnum&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_fxnum_fast&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );

    sc_fxnum( int64, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( uint64, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_int_base&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_uint_base&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_signed&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );
    sc_fxnum( const sc_unsigned&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_observer* );




    ~sc_fxnum();



    const scfx_rep* get_rep() const;

public:



    const sc_fxval operator - () const;
    const sc_fxval operator + () const;




    friend void neg( sc_fxval&, const sc_fxnum& );
    friend void neg( sc_fxnum&, const sc_fxnum& );
# 640 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend const sc_fxval operator * ( const sc_fxnum&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, int ); friend const sc_fxval operator * ( int, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, unsigned int ); friend const sc_fxval operator * ( unsigned int, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, long ); friend const sc_fxval operator * ( long, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, unsigned long ); friend const sc_fxval operator * ( unsigned long, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, double ); friend const sc_fxval operator * ( double, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const char* ); friend const sc_fxval operator * ( const char*, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_fxval& ); friend const sc_fxval operator * ( const sc_fxval&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_fxval_fast& ); friend const sc_fxval operator * ( const sc_fxval_fast&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_fxnum_fast& ); friend const sc_fxval operator * ( const sc_fxnum_fast&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, int64 ); friend const sc_fxval operator * ( int64, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, uint64 ); friend const sc_fxval operator * ( uint64, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_int_base& ); friend const sc_fxval operator * ( const sc_int_base&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_uint_base& ); friend const sc_fxval operator * ( const sc_uint_base&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_signed& ); friend const sc_fxval operator * ( const sc_signed&, const sc_fxnum& ); friend const sc_fxval operator * ( const sc_fxnum&, const sc_unsigned& ); friend const sc_fxval operator * ( const sc_unsigned&, const sc_fxnum& );
    friend const sc_fxval operator + ( const sc_fxnum&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, int ); friend const sc_fxval operator + ( int, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, unsigned int ); friend const sc_fxval operator + ( unsigned int, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, long ); friend const sc_fxval operator + ( long, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, unsigned long ); friend const sc_fxval operator + ( unsigned long, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, double ); friend const sc_fxval operator + ( double, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const char* ); friend const sc_fxval operator + ( const char*, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_fxval& ); friend const sc_fxval operator + ( const sc_fxval&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_fxval_fast& ); friend const sc_fxval operator + ( const sc_fxval_fast&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_fxnum_fast& ); friend const sc_fxval operator + ( const sc_fxnum_fast&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, int64 ); friend const sc_fxval operator + ( int64, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, uint64 ); friend const sc_fxval operator + ( uint64, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_int_base& ); friend const sc_fxval operator + ( const sc_int_base&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_uint_base& ); friend const sc_fxval operator + ( const sc_uint_base&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_signed& ); friend const sc_fxval operator + ( const sc_signed&, const sc_fxnum& ); friend const sc_fxval operator + ( const sc_fxnum&, const sc_unsigned& ); friend const sc_fxval operator + ( const sc_unsigned&, const sc_fxnum& );
    friend const sc_fxval operator - ( const sc_fxnum&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, int ); friend const sc_fxval operator - ( int, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, unsigned int ); friend const sc_fxval operator - ( unsigned int, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, long ); friend const sc_fxval operator - ( long, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, unsigned long ); friend const sc_fxval operator - ( unsigned long, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, double ); friend const sc_fxval operator - ( double, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const char* ); friend const sc_fxval operator - ( const char*, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_fxval& ); friend const sc_fxval operator - ( const sc_fxval&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_fxval_fast& ); friend const sc_fxval operator - ( const sc_fxval_fast&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_fxnum_fast& ); friend const sc_fxval operator - ( const sc_fxnum_fast&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, int64 ); friend const sc_fxval operator - ( int64, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, uint64 ); friend const sc_fxval operator - ( uint64, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_int_base& ); friend const sc_fxval operator - ( const sc_int_base&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_uint_base& ); friend const sc_fxval operator - ( const sc_uint_base&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_signed& ); friend const sc_fxval operator - ( const sc_signed&, const sc_fxnum& ); friend const sc_fxval operator - ( const sc_fxnum&, const sc_unsigned& ); friend const sc_fxval operator - ( const sc_unsigned&, const sc_fxnum& );


    friend const sc_fxval operator / ( const sc_fxnum&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, int ); friend const sc_fxval operator / ( int, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, unsigned int ); friend const sc_fxval operator / ( unsigned int, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, long ); friend const sc_fxval operator / ( long, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, unsigned long ); friend const sc_fxval operator / ( unsigned long, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, double ); friend const sc_fxval operator / ( double, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const char* ); friend const sc_fxval operator / ( const char*, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_fxval& ); friend const sc_fxval operator / ( const sc_fxval&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_fxval_fast& ); friend const sc_fxval operator / ( const sc_fxval_fast&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_fxnum_fast& ); friend const sc_fxval operator / ( const sc_fxnum_fast&, const sc_fxnum& );


    friend const sc_fxval operator / ( const sc_fxnum&, int64 ); friend const sc_fxval operator / ( int64, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, uint64 ); friend const sc_fxval operator / ( uint64, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_int_base& ); friend const sc_fxval operator / ( const sc_int_base&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_uint_base& ); friend const sc_fxval operator / ( const sc_uint_base&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_signed& ); friend const sc_fxval operator / ( const sc_signed&, const sc_fxnum& );
    friend const sc_fxval operator / ( const sc_fxnum&, const sc_unsigned& ); friend const sc_fxval operator / ( const sc_unsigned&, const sc_fxnum& );






    friend const sc_fxval operator << ( const sc_fxnum&, int );
    friend const sc_fxval operator >> ( const sc_fxnum&, int );
# 707 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend void mult ( sc_fxval&, const sc_fxnum&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, int ); friend void mult ( sc_fxval&, int, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, int ); friend void mult ( sc_fxnum&, int, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, unsigned int ); friend void mult ( sc_fxval&, unsigned int, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, unsigned int ); friend void mult ( sc_fxnum&, unsigned int, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, long ); friend void mult ( sc_fxval&, long, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, long ); friend void mult ( sc_fxnum&, long, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, unsigned long ); friend void mult ( sc_fxval&, unsigned long, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, unsigned long ); friend void mult ( sc_fxnum&, unsigned long, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, double ); friend void mult ( sc_fxval&, double, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, double ); friend void mult ( sc_fxnum&, double, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const char* ); friend void mult ( sc_fxval&, const char*, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const char* ); friend void mult ( sc_fxnum&, const char*, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_fxval& ); friend void mult ( sc_fxval&, const sc_fxval&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_fxval& ); friend void mult ( sc_fxnum&, const sc_fxval&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_fxval_fast& ); friend void mult ( sc_fxval&, const sc_fxval_fast&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_fxval_fast& ); friend void mult ( sc_fxnum&, const sc_fxval_fast&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_fxnum_fast& ); friend void mult ( sc_fxval&, const sc_fxnum_fast&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum&, const sc_fxnum_fast&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, int64 ); friend void mult ( sc_fxval&, int64, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, int64 ); friend void mult ( sc_fxnum&, int64, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, uint64 ); friend void mult ( sc_fxval&, uint64, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, uint64 ); friend void mult ( sc_fxnum&, uint64, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_int_base& ); friend void mult ( sc_fxval&, const sc_int_base&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_int_base& ); friend void mult ( sc_fxnum&, const sc_int_base&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_uint_base& ); friend void mult ( sc_fxval&, const sc_uint_base&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_uint_base& ); friend void mult ( sc_fxnum&, const sc_uint_base&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_signed& ); friend void mult ( sc_fxval&, const sc_signed&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_signed& ); friend void mult ( sc_fxnum&, const sc_signed&, const sc_fxnum& ); friend void mult ( sc_fxval&, const sc_fxnum&, const sc_unsigned& ); friend void mult ( sc_fxval&, const sc_unsigned&, const sc_fxnum& ); friend void mult ( sc_fxnum&, const sc_fxnum&, const sc_unsigned& ); friend void mult ( sc_fxnum&, const sc_unsigned&, const sc_fxnum& );
    friend void div ( sc_fxval&, const sc_fxnum&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, int ); friend void div ( sc_fxval&, int, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, int ); friend void div ( sc_fxnum&, int, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, unsigned int ); friend void div ( sc_fxval&, unsigned int, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, unsigned int ); friend void div ( sc_fxnum&, unsigned int, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, long ); friend void div ( sc_fxval&, long, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, long ); friend void div ( sc_fxnum&, long, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, unsigned long ); friend void div ( sc_fxval&, unsigned long, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, unsigned long ); friend void div ( sc_fxnum&, unsigned long, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, double ); friend void div ( sc_fxval&, double, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, double ); friend void div ( sc_fxnum&, double, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const char* ); friend void div ( sc_fxval&, const char*, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const char* ); friend void div ( sc_fxnum&, const char*, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_fxval& ); friend void div ( sc_fxval&, const sc_fxval&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_fxval& ); friend void div ( sc_fxnum&, const sc_fxval&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_fxval_fast& ); friend void div ( sc_fxval&, const sc_fxval_fast&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_fxval_fast& ); friend void div ( sc_fxnum&, const sc_fxval_fast&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_fxnum_fast& ); friend void div ( sc_fxval&, const sc_fxnum_fast&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_fxnum_fast& ); friend void div ( sc_fxnum&, const sc_fxnum_fast&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, int64 ); friend void div ( sc_fxval&, int64, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, int64 ); friend void div ( sc_fxnum&, int64, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, uint64 ); friend void div ( sc_fxval&, uint64, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, uint64 ); friend void div ( sc_fxnum&, uint64, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_int_base& ); friend void div ( sc_fxval&, const sc_int_base&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_int_base& ); friend void div ( sc_fxnum&, const sc_int_base&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_uint_base& ); friend void div ( sc_fxval&, const sc_uint_base&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_uint_base& ); friend void div ( sc_fxnum&, const sc_uint_base&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_signed& ); friend void div ( sc_fxval&, const sc_signed&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_signed& ); friend void div ( sc_fxnum&, const sc_signed&, const sc_fxnum& ); friend void div ( sc_fxval&, const sc_fxnum&, const sc_unsigned& ); friend void div ( sc_fxval&, const sc_unsigned&, const sc_fxnum& ); friend void div ( sc_fxnum&, const sc_fxnum&, const sc_unsigned& ); friend void div ( sc_fxnum&, const sc_unsigned&, const sc_fxnum& );
    friend void add ( sc_fxval&, const sc_fxnum&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, int ); friend void add ( sc_fxval&, int, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, int ); friend void add ( sc_fxnum&, int, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, unsigned int ); friend void add ( sc_fxval&, unsigned int, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, unsigned int ); friend void add ( sc_fxnum&, unsigned int, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, long ); friend void add ( sc_fxval&, long, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, long ); friend void add ( sc_fxnum&, long, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, unsigned long ); friend void add ( sc_fxval&, unsigned long, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, unsigned long ); friend void add ( sc_fxnum&, unsigned long, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, double ); friend void add ( sc_fxval&, double, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, double ); friend void add ( sc_fxnum&, double, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const char* ); friend void add ( sc_fxval&, const char*, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const char* ); friend void add ( sc_fxnum&, const char*, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_fxval& ); friend void add ( sc_fxval&, const sc_fxval&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_fxval& ); friend void add ( sc_fxnum&, const sc_fxval&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_fxval_fast& ); friend void add ( sc_fxval&, const sc_fxval_fast&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_fxval_fast& ); friend void add ( sc_fxnum&, const sc_fxval_fast&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_fxnum_fast& ); friend void add ( sc_fxval&, const sc_fxnum_fast&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_fxnum_fast& ); friend void add ( sc_fxnum&, const sc_fxnum_fast&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, int64 ); friend void add ( sc_fxval&, int64, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, int64 ); friend void add ( sc_fxnum&, int64, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, uint64 ); friend void add ( sc_fxval&, uint64, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, uint64 ); friend void add ( sc_fxnum&, uint64, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_int_base& ); friend void add ( sc_fxval&, const sc_int_base&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_int_base& ); friend void add ( sc_fxnum&, const sc_int_base&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_uint_base& ); friend void add ( sc_fxval&, const sc_uint_base&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_uint_base& ); friend void add ( sc_fxnum&, const sc_uint_base&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_signed& ); friend void add ( sc_fxval&, const sc_signed&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_signed& ); friend void add ( sc_fxnum&, const sc_signed&, const sc_fxnum& ); friend void add ( sc_fxval&, const sc_fxnum&, const sc_unsigned& ); friend void add ( sc_fxval&, const sc_unsigned&, const sc_fxnum& ); friend void add ( sc_fxnum&, const sc_fxnum&, const sc_unsigned& ); friend void add ( sc_fxnum&, const sc_unsigned&, const sc_fxnum& );
    friend void sub ( sc_fxval&, const sc_fxnum&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, int ); friend void sub ( sc_fxval&, int, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, int ); friend void sub ( sc_fxnum&, int, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, unsigned int ); friend void sub ( sc_fxval&, unsigned int, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, unsigned int ); friend void sub ( sc_fxnum&, unsigned int, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, long ); friend void sub ( sc_fxval&, long, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, long ); friend void sub ( sc_fxnum&, long, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, unsigned long ); friend void sub ( sc_fxval&, unsigned long, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, unsigned long ); friend void sub ( sc_fxnum&, unsigned long, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, double ); friend void sub ( sc_fxval&, double, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, double ); friend void sub ( sc_fxnum&, double, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const char* ); friend void sub ( sc_fxval&, const char*, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const char* ); friend void sub ( sc_fxnum&, const char*, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_fxval& ); friend void sub ( sc_fxval&, const sc_fxval&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_fxval& ); friend void sub ( sc_fxnum&, const sc_fxval&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_fxval_fast& ); friend void sub ( sc_fxval&, const sc_fxval_fast&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_fxval_fast& ); friend void sub ( sc_fxnum&, const sc_fxval_fast&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_fxnum_fast& ); friend void sub ( sc_fxval&, const sc_fxnum_fast&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum&, const sc_fxnum_fast&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, int64 ); friend void sub ( sc_fxval&, int64, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, int64 ); friend void sub ( sc_fxnum&, int64, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, uint64 ); friend void sub ( sc_fxval&, uint64, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, uint64 ); friend void sub ( sc_fxnum&, uint64, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_int_base& ); friend void sub ( sc_fxval&, const sc_int_base&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_int_base& ); friend void sub ( sc_fxnum&, const sc_int_base&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_uint_base& ); friend void sub ( sc_fxval&, const sc_uint_base&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_uint_base& ); friend void sub ( sc_fxnum&, const sc_uint_base&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_signed& ); friend void sub ( sc_fxval&, const sc_signed&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_signed& ); friend void sub ( sc_fxnum&, const sc_signed&, const sc_fxnum& ); friend void sub ( sc_fxval&, const sc_fxnum&, const sc_unsigned& ); friend void sub ( sc_fxval&, const sc_unsigned&, const sc_fxnum& ); friend void sub ( sc_fxnum&, const sc_fxnum&, const sc_unsigned& ); friend void sub ( sc_fxnum&, const sc_unsigned&, const sc_fxnum& );





    friend void lshift( sc_fxval&, const sc_fxnum&, int );
    friend void rshift( sc_fxval&, const sc_fxnum&, int );
    friend void lshift( sc_fxnum&, const sc_fxnum&, int );
    friend void rshift( sc_fxnum&, const sc_fxnum&, int );
# 753 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend bool operator < ( const sc_fxnum&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, int ); friend bool operator < ( int, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, unsigned int ); friend bool operator < ( unsigned int, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, long ); friend bool operator < ( long, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, unsigned long ); friend bool operator < ( unsigned long, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, double ); friend bool operator < ( double, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const char* ); friend bool operator < ( const char*, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_fxval& ); friend bool operator < ( const sc_fxval&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, int64 ); friend bool operator < ( int64, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, uint64 ); friend bool operator < ( uint64, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_int_base& ); friend bool operator < ( const sc_int_base&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_uint_base& ); friend bool operator < ( const sc_uint_base&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_signed& ); friend bool operator < ( const sc_signed&, const sc_fxnum& ); friend bool operator < ( const sc_fxnum&, const sc_unsigned& ); friend bool operator < ( const sc_unsigned&, const sc_fxnum& );
    friend bool operator <= ( const sc_fxnum&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, int ); friend bool operator <= ( int, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, unsigned int ); friend bool operator <= ( unsigned int, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, long ); friend bool operator <= ( long, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, unsigned long ); friend bool operator <= ( unsigned long, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, double ); friend bool operator <= ( double, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const char* ); friend bool operator <= ( const char*, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_fxval& ); friend bool operator <= ( const sc_fxval&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, int64 ); friend bool operator <= ( int64, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, uint64 ); friend bool operator <= ( uint64, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_int_base& ); friend bool operator <= ( const sc_int_base&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_uint_base& ); friend bool operator <= ( const sc_uint_base&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_signed& ); friend bool operator <= ( const sc_signed&, const sc_fxnum& ); friend bool operator <= ( const sc_fxnum&, const sc_unsigned& ); friend bool operator <= ( const sc_unsigned&, const sc_fxnum& );
    friend bool operator > ( const sc_fxnum&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, int ); friend bool operator > ( int, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, unsigned int ); friend bool operator > ( unsigned int, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, long ); friend bool operator > ( long, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, unsigned long ); friend bool operator > ( unsigned long, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, double ); friend bool operator > ( double, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const char* ); friend bool operator > ( const char*, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_fxval& ); friend bool operator > ( const sc_fxval&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, int64 ); friend bool operator > ( int64, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, uint64 ); friend bool operator > ( uint64, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_int_base& ); friend bool operator > ( const sc_int_base&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_uint_base& ); friend bool operator > ( const sc_uint_base&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_signed& ); friend bool operator > ( const sc_signed&, const sc_fxnum& ); friend bool operator > ( const sc_fxnum&, const sc_unsigned& ); friend bool operator > ( const sc_unsigned&, const sc_fxnum& );
    friend bool operator >= ( const sc_fxnum&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, int ); friend bool operator >= ( int, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, unsigned int ); friend bool operator >= ( unsigned int, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, long ); friend bool operator >= ( long, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, unsigned long ); friend bool operator >= ( unsigned long, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, double ); friend bool operator >= ( double, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const char* ); friend bool operator >= ( const char*, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_fxval& ); friend bool operator >= ( const sc_fxval&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, int64 ); friend bool operator >= ( int64, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, uint64 ); friend bool operator >= ( uint64, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_int_base& ); friend bool operator >= ( const sc_int_base&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_uint_base& ); friend bool operator >= ( const sc_uint_base&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_signed& ); friend bool operator >= ( const sc_signed&, const sc_fxnum& ); friend bool operator >= ( const sc_fxnum&, const sc_unsigned& ); friend bool operator >= ( const sc_unsigned&, const sc_fxnum& );
    friend bool operator == ( const sc_fxnum&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, int ); friend bool operator == ( int, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, long ); friend bool operator == ( long, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, double ); friend bool operator == ( double, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const char* ); friend bool operator == ( const char*, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_fxval& ); friend bool operator == ( const sc_fxval&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, int64 ); friend bool operator == ( int64, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, uint64 ); friend bool operator == ( uint64, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_int_base& ); friend bool operator == ( const sc_int_base&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_uint_base& ); friend bool operator == ( const sc_uint_base&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxnum& ); friend bool operator == ( const sc_fxnum&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxnum& );
    friend bool operator != ( const sc_fxnum&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, int ); friend bool operator != ( int, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, long ); friend bool operator != ( long, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, double ); friend bool operator != ( double, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const char* ); friend bool operator != ( const char*, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_fxval& ); friend bool operator != ( const sc_fxval&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, int64 ); friend bool operator != ( int64, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, uint64 ); friend bool operator != ( uint64, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_int_base& ); friend bool operator != ( const sc_int_base&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_uint_base& ); friend bool operator != ( const sc_uint_base&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxnum& ); friend bool operator != ( const sc_fxnum&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxnum& );
# 795 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum& operator =( int ); sc_fxnum& operator =( unsigned int ); sc_fxnum& operator =( long ); sc_fxnum& operator =( unsigned long ); sc_fxnum& operator =( double ); sc_fxnum& operator =( const char* ); sc_fxnum& operator =( const sc_fxval& ); sc_fxnum& operator =( const sc_fxval_fast& ); sc_fxnum& operator =( const sc_fxnum& ); sc_fxnum& operator =( const sc_fxnum_fast& ); sc_fxnum& operator =( int64 ); sc_fxnum& operator =( uint64 ); sc_fxnum& operator =( const sc_int_base& ); sc_fxnum& operator =( const sc_uint_base& ); sc_fxnum& operator =( const sc_signed& ); sc_fxnum& operator =( const sc_unsigned& );

    sc_fxnum& operator *=( int ); sc_fxnum& operator *=( unsigned int ); sc_fxnum& operator *=( long ); sc_fxnum& operator *=( unsigned long ); sc_fxnum& operator *=( double ); sc_fxnum& operator *=( const char* ); sc_fxnum& operator *=( const sc_fxval& ); sc_fxnum& operator *=( const sc_fxval_fast& ); sc_fxnum& operator *=( const sc_fxnum& ); sc_fxnum& operator *=( const sc_fxnum_fast& ); sc_fxnum& operator *=( int64 ); sc_fxnum& operator *=( uint64 ); sc_fxnum& operator *=( const sc_int_base& ); sc_fxnum& operator *=( const sc_uint_base& ); sc_fxnum& operator *=( const sc_signed& ); sc_fxnum& operator *=( const sc_unsigned& );
    sc_fxnum& operator /=( int ); sc_fxnum& operator /=( unsigned int ); sc_fxnum& operator /=( long ); sc_fxnum& operator /=( unsigned long ); sc_fxnum& operator /=( double ); sc_fxnum& operator /=( const char* ); sc_fxnum& operator /=( const sc_fxval& ); sc_fxnum& operator /=( const sc_fxval_fast& ); sc_fxnum& operator /=( const sc_fxnum& ); sc_fxnum& operator /=( const sc_fxnum_fast& ); sc_fxnum& operator /=( int64 ); sc_fxnum& operator /=( uint64 ); sc_fxnum& operator /=( const sc_int_base& ); sc_fxnum& operator /=( const sc_uint_base& ); sc_fxnum& operator /=( const sc_signed& ); sc_fxnum& operator /=( const sc_unsigned& );
    sc_fxnum& operator +=( int ); sc_fxnum& operator +=( unsigned int ); sc_fxnum& operator +=( long ); sc_fxnum& operator +=( unsigned long ); sc_fxnum& operator +=( double ); sc_fxnum& operator +=( const char* ); sc_fxnum& operator +=( const sc_fxval& ); sc_fxnum& operator +=( const sc_fxval_fast& ); sc_fxnum& operator +=( const sc_fxnum& ); sc_fxnum& operator +=( const sc_fxnum_fast& ); sc_fxnum& operator +=( int64 ); sc_fxnum& operator +=( uint64 ); sc_fxnum& operator +=( const sc_int_base& ); sc_fxnum& operator +=( const sc_uint_base& ); sc_fxnum& operator +=( const sc_signed& ); sc_fxnum& operator +=( const sc_unsigned& );
    sc_fxnum& operator -=( int ); sc_fxnum& operator -=( unsigned int ); sc_fxnum& operator -=( long ); sc_fxnum& operator -=( unsigned long ); sc_fxnum& operator -=( double ); sc_fxnum& operator -=( const char* ); sc_fxnum& operator -=( const sc_fxval& ); sc_fxnum& operator -=( const sc_fxval_fast& ); sc_fxnum& operator -=( const sc_fxnum& ); sc_fxnum& operator -=( const sc_fxnum_fast& ); sc_fxnum& operator -=( int64 ); sc_fxnum& operator -=( uint64 ); sc_fxnum& operator -=( const sc_int_base& ); sc_fxnum& operator -=( const sc_uint_base& ); sc_fxnum& operator -=( const sc_signed& ); sc_fxnum& operator -=( const sc_unsigned& );

    sc_fxnum& operator <<=( int );
    sc_fxnum& operator >>=( int );
# 812 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    const sc_fxval operator ++ ( int );
    const sc_fxval operator -- ( int );

    sc_fxnum& operator ++ ();
    sc_fxnum& operator -- ();




    const sc_fxnum_bitref operator [] ( int ) const;
    sc_fxnum_bitref operator [] ( int );

    const sc_fxnum_bitref bit( int ) const;
    sc_fxnum_bitref bit( int );




    const sc_fxnum_subref operator () ( int, int ) const;
    sc_fxnum_subref operator () ( int, int );

    const sc_fxnum_subref range( int, int ) const;
    sc_fxnum_subref range( int, int );


    const sc_fxnum_subref operator () () const;
    sc_fxnum_subref operator () ();

    const sc_fxnum_subref range() const;
    sc_fxnum_subref range();




    operator double() const;




    short to_short() const;
    unsigned short to_ushort() const;
    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    float to_float() const;
    double to_double() const;




    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;
    const sc_string to_string( sc_fmt ) const;
    const sc_string to_string( sc_numrep, sc_fmt ) const;
    const sc_string to_string( sc_numrep, bool, sc_fmt ) const;

    const sc_string to_dec() const;
    const sc_string to_bin() const;
    const sc_string to_oct() const;
    const sc_string to_hex() const;




    bool is_neg() const;
    bool is_zero() const;


    bool is_normal() const;

    bool quantization_flag() const;
    bool overflow_flag() const;

    const sc_fxval value() const;




    int wl() const;
    int iwl() const;
    sc_q_mode q_mode() const;
    sc_o_mode o_mode() const;
    int n_bits() const;

    const sc_fxtype_params& type_params() const;

    const sc_fxcast_switch& cast_switch() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;



    void observer_read() const;



    bool get_bit( int ) const;

protected:

    bool set_bit( int, bool );


    bool get_slice( int, int, sc_bv_base& ) const;
    bool set_slice( int, int, const sc_bv_base& );


    sc_fxnum_observer* lock_observer() const;
    void unlock_observer( sc_fxnum_observer* ) const;

private:

    scfx_rep* m_rep;

    scfx_params m_params;
    bool m_q_flag;
    bool m_o_flag;

    mutable sc_fxnum_observer* m_observer;

private:


    sc_fxnum();
    sc_fxnum( const sc_fxnum& );
};
# 953 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
class sc_fxnum_fast
{
    friend class sc_fxval_fast;

    friend class sc_fxnum_bitref;
    friend class sc_fxnum_subref;
    friend class sc_fxnum_fast_bitref;
    friend class sc_fxnum_fast_subref;

    friend class ::vcd_sc_fxnum_fast_trace;
    friend class ::wif_sc_fxnum_fast_trace;

protected:

    sc_fxnum_fast_observer* observer() const;


    void cast();




    sc_fxnum_fast( const sc_fxtype_params&,
     sc_enc,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* );
# 987 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_fast( int, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( unsigned int, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( long, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( unsigned long, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( double, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const char*, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_fxval&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_fxval_fast&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_fxnum&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_fxnum_fast&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );

    sc_fxnum_fast( int64, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( uint64, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_int_base&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_uint_base&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_signed&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );
    sc_fxnum_fast( const sc_unsigned&, const sc_fxtype_params&, sc_enc, const sc_fxcast_switch&, sc_fxnum_fast_observer* );




    ~sc_fxnum_fast();



    double get_val() const;

public:



    const sc_fxval_fast operator - () const;
    const sc_fxval_fast operator + () const;




    friend void neg( sc_fxval_fast&, const sc_fxnum_fast& );
    friend void neg( sc_fxnum_fast&, const sc_fxnum_fast& );
# 1058 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, int ); friend const sc_fxval_fast operator * ( int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, unsigned int ); friend const sc_fxval_fast operator * ( unsigned int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, long ); friend const sc_fxval_fast operator * ( long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, unsigned long ); friend const sc_fxval_fast operator * ( unsigned long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, double ); friend const sc_fxval_fast operator * ( double, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const char* ); friend const sc_fxval_fast operator * ( const char*, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator * ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, int64 ); friend const sc_fxval_fast operator * ( int64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, uint64 ); friend const sc_fxval_fast operator * ( uint64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_int_base& ); friend const sc_fxval_fast operator * ( const sc_int_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator * ( const sc_uint_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_signed& ); friend const sc_fxval_fast operator * ( const sc_signed&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator * ( const sc_fxnum_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator * ( const sc_unsigned&, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, int ); friend const sc_fxval_fast operator + ( int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, unsigned int ); friend const sc_fxval_fast operator + ( unsigned int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, long ); friend const sc_fxval_fast operator + ( long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, unsigned long ); friend const sc_fxval_fast operator + ( unsigned long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, double ); friend const sc_fxval_fast operator + ( double, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const char* ); friend const sc_fxval_fast operator + ( const char*, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator + ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, int64 ); friend const sc_fxval_fast operator + ( int64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, uint64 ); friend const sc_fxval_fast operator + ( uint64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_int_base& ); friend const sc_fxval_fast operator + ( const sc_int_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator + ( const sc_uint_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_signed& ); friend const sc_fxval_fast operator + ( const sc_signed&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator + ( const sc_fxnum_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator + ( const sc_unsigned&, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, int ); friend const sc_fxval_fast operator - ( int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, unsigned int ); friend const sc_fxval_fast operator - ( unsigned int, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, long ); friend const sc_fxval_fast operator - ( long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, unsigned long ); friend const sc_fxval_fast operator - ( unsigned long, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, double ); friend const sc_fxval_fast operator - ( double, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const char* ); friend const sc_fxval_fast operator - ( const char*, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator - ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, int64 ); friend const sc_fxval_fast operator - ( int64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, uint64 ); friend const sc_fxval_fast operator - ( uint64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_int_base& ); friend const sc_fxval_fast operator - ( const sc_int_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator - ( const sc_uint_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_signed& ); friend const sc_fxval_fast operator - ( const sc_signed&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator - ( const sc_fxnum_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator - ( const sc_unsigned&, const sc_fxnum_fast& );

    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&,
          const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, int ); friend const sc_fxval_fast operator / ( int, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, unsigned int ); friend const sc_fxval_fast operator / ( unsigned int, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, long ); friend const sc_fxval_fast operator / ( long, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, unsigned long ); friend const sc_fxval_fast operator / ( unsigned long, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, double ); friend const sc_fxval_fast operator / ( double, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const char* ); friend const sc_fxval_fast operator / ( const char*, const sc_fxnum_fast& );
    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend const sc_fxval_fast operator / ( const sc_fxval_fast&, const sc_fxnum_fast& );


    friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, int64 ); friend const sc_fxval_fast operator / ( int64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, uint64 ); friend const sc_fxval_fast operator / ( uint64, const sc_fxnum_fast& ); friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const sc_int_base& ); friend const sc_fxval_fast operator / ( const sc_int_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const sc_uint_base& ); friend const sc_fxval_fast operator / ( const sc_uint_base&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const sc_signed& ); friend const sc_fxval_fast operator / ( const sc_signed&, const sc_fxnum_fast& ); friend const sc_fxval_fast operator / ( const sc_fxnum_fast&, const sc_unsigned& ); friend const sc_fxval_fast operator / ( const sc_unsigned&, const sc_fxnum_fast& );
# 1085 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend const sc_fxval_fast operator << ( const sc_fxnum_fast&, int );
    friend const sc_fxval_fast operator >> ( const sc_fxnum_fast&, int );
# 1125 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, int ); friend void mult ( sc_fxval_fast&, int, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, int ); friend void mult ( sc_fxnum_fast&, int, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned int ); friend void mult ( sc_fxval_fast&, unsigned int, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned int ); friend void mult ( sc_fxnum_fast&, unsigned int, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, long ); friend void mult ( sc_fxval_fast&, long, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, long ); friend void mult ( sc_fxnum_fast&, long, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned long ); friend void mult ( sc_fxval_fast&, unsigned long, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned long ); friend void mult ( sc_fxnum_fast&, unsigned long, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, double ); friend void mult ( sc_fxval_fast&, double, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, double ); friend void mult ( sc_fxnum_fast&, double, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const char* ); friend void mult ( sc_fxval_fast&, const char*, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const char* ); friend void mult ( sc_fxnum_fast&, const char*, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void mult ( sc_fxval_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void mult ( sc_fxnum_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void mult ( sc_fxval_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, int64 ); friend void mult ( sc_fxval_fast&, int64, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, int64 ); friend void mult ( sc_fxnum_fast&, int64, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, uint64 ); friend void mult ( sc_fxval_fast&, uint64, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, uint64 ); friend void mult ( sc_fxnum_fast&, uint64, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void mult ( sc_fxval_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void mult ( sc_fxnum_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void mult ( sc_fxval_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void mult ( sc_fxnum_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void mult ( sc_fxval_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void mult ( sc_fxnum_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void mult ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void mult ( sc_fxval_fast&, const sc_unsigned&, const sc_fxnum_fast& ); friend void mult ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void mult ( sc_fxnum_fast&, const sc_unsigned&, const sc_fxnum_fast& );
    friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, int ); friend void div ( sc_fxval_fast&, int, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, int ); friend void div ( sc_fxnum_fast&, int, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned int ); friend void div ( sc_fxval_fast&, unsigned int, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned int ); friend void div ( sc_fxnum_fast&, unsigned int, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, long ); friend void div ( sc_fxval_fast&, long, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, long ); friend void div ( sc_fxnum_fast&, long, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned long ); friend void div ( sc_fxval_fast&, unsigned long, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned long ); friend void div ( sc_fxnum_fast&, unsigned long, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, double ); friend void div ( sc_fxval_fast&, double, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, double ); friend void div ( sc_fxnum_fast&, double, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const char* ); friend void div ( sc_fxval_fast&, const char*, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const char* ); friend void div ( sc_fxnum_fast&, const char*, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void div ( sc_fxval_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void div ( sc_fxnum_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void div ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void div ( sc_fxval_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void div ( sc_fxnum_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, int64 ); friend void div ( sc_fxval_fast&, int64, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, int64 ); friend void div ( sc_fxnum_fast&, int64, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, uint64 ); friend void div ( sc_fxval_fast&, uint64, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, uint64 ); friend void div ( sc_fxnum_fast&, uint64, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void div ( sc_fxval_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void div ( sc_fxnum_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void div ( sc_fxval_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void div ( sc_fxnum_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void div ( sc_fxval_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void div ( sc_fxnum_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void div ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void div ( sc_fxval_fast&, const sc_unsigned&, const sc_fxnum_fast& ); friend void div ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void div ( sc_fxnum_fast&, const sc_unsigned&, const sc_fxnum_fast& );
    friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, int ); friend void add ( sc_fxval_fast&, int, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, int ); friend void add ( sc_fxnum_fast&, int, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned int ); friend void add ( sc_fxval_fast&, unsigned int, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned int ); friend void add ( sc_fxnum_fast&, unsigned int, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, long ); friend void add ( sc_fxval_fast&, long, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, long ); friend void add ( sc_fxnum_fast&, long, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned long ); friend void add ( sc_fxval_fast&, unsigned long, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned long ); friend void add ( sc_fxnum_fast&, unsigned long, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, double ); friend void add ( sc_fxval_fast&, double, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, double ); friend void add ( sc_fxnum_fast&, double, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const char* ); friend void add ( sc_fxval_fast&, const char*, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const char* ); friend void add ( sc_fxnum_fast&, const char*, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void add ( sc_fxval_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void add ( sc_fxnum_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void add ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void add ( sc_fxval_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void add ( sc_fxnum_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, int64 ); friend void add ( sc_fxval_fast&, int64, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, int64 ); friend void add ( sc_fxnum_fast&, int64, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, uint64 ); friend void add ( sc_fxval_fast&, uint64, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, uint64 ); friend void add ( sc_fxnum_fast&, uint64, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void add ( sc_fxval_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void add ( sc_fxnum_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void add ( sc_fxval_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void add ( sc_fxnum_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void add ( sc_fxval_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void add ( sc_fxnum_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void add ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void add ( sc_fxval_fast&, const sc_unsigned&, const sc_fxnum_fast& ); friend void add ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void add ( sc_fxnum_fast&, const sc_unsigned&, const sc_fxnum_fast& );
    friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, int ); friend void sub ( sc_fxval_fast&, int, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, int ); friend void sub ( sc_fxnum_fast&, int, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned int ); friend void sub ( sc_fxval_fast&, unsigned int, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned int ); friend void sub ( sc_fxnum_fast&, unsigned int, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, long ); friend void sub ( sc_fxval_fast&, long, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, long ); friend void sub ( sc_fxnum_fast&, long, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, unsigned long ); friend void sub ( sc_fxval_fast&, unsigned long, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, unsigned long ); friend void sub ( sc_fxnum_fast&, unsigned long, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, double ); friend void sub ( sc_fxval_fast&, double, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, double ); friend void sub ( sc_fxnum_fast&, double, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const char* ); friend void sub ( sc_fxval_fast&, const char*, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const char* ); friend void sub ( sc_fxnum_fast&, const char*, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void sub ( sc_fxval_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval& ); friend void sub ( sc_fxnum_fast&, const sc_fxval&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxval_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxval_fast&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void sub ( sc_fxval_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_fxnum& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, int64 ); friend void sub ( sc_fxval_fast&, int64, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, int64 ); friend void sub ( sc_fxnum_fast&, int64, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, uint64 ); friend void sub ( sc_fxval_fast&, uint64, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, uint64 ); friend void sub ( sc_fxnum_fast&, uint64, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void sub ( sc_fxval_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_int_base& ); friend void sub ( sc_fxnum_fast&, const sc_int_base&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void sub ( sc_fxval_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_uint_base& ); friend void sub ( sc_fxnum_fast&, const sc_uint_base&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void sub ( sc_fxval_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_signed& ); friend void sub ( sc_fxnum_fast&, const sc_signed&, const sc_fxnum_fast& ); friend void sub ( sc_fxval_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void sub ( sc_fxval_fast&, const sc_unsigned&, const sc_fxnum_fast& ); friend void sub ( sc_fxnum_fast&, const sc_fxnum_fast&, const sc_unsigned& ); friend void sub ( sc_fxnum_fast&, const sc_unsigned&, const sc_fxnum_fast& );





    friend void lshift( sc_fxval_fast&, const sc_fxnum_fast&, int );
    friend void rshift( sc_fxval_fast&, const sc_fxnum_fast&, int );
    friend void lshift( sc_fxnum_fast&, const sc_fxnum_fast&, int );
    friend void rshift( sc_fxnum_fast&, const sc_fxnum_fast&, int );
# 1169 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    friend bool operator < ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, int ); friend bool operator < ( int, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, unsigned int ); friend bool operator < ( unsigned int, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, long ); friend bool operator < ( long, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, unsigned long ); friend bool operator < ( unsigned long, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, double ); friend bool operator < ( double, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const char* ); friend bool operator < ( const char*, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator < ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, int64 ); friend bool operator < ( int64, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, uint64 ); friend bool operator < ( uint64, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator < ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator < ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator < ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator < ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator < ( const sc_unsigned&, const sc_fxnum_fast& );
    friend bool operator <= ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, int ); friend bool operator <= ( int, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, unsigned int ); friend bool operator <= ( unsigned int, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, long ); friend bool operator <= ( long, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, unsigned long ); friend bool operator <= ( unsigned long, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, double ); friend bool operator <= ( double, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const char* ); friend bool operator <= ( const char*, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator <= ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, int64 ); friend bool operator <= ( int64, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, uint64 ); friend bool operator <= ( uint64, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator <= ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator <= ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator <= ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator <= ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator <= ( const sc_unsigned&, const sc_fxnum_fast& );
    friend bool operator > ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, int ); friend bool operator > ( int, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, unsigned int ); friend bool operator > ( unsigned int, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, long ); friend bool operator > ( long, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, unsigned long ); friend bool operator > ( unsigned long, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, double ); friend bool operator > ( double, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const char* ); friend bool operator > ( const char*, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator > ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, int64 ); friend bool operator > ( int64, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, uint64 ); friend bool operator > ( uint64, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator > ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator > ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator > ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator > ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator > ( const sc_unsigned&, const sc_fxnum_fast& );
    friend bool operator >= ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, int ); friend bool operator >= ( int, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, unsigned int ); friend bool operator >= ( unsigned int, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, long ); friend bool operator >= ( long, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, unsigned long ); friend bool operator >= ( unsigned long, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, double ); friend bool operator >= ( double, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const char* ); friend bool operator >= ( const char*, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator >= ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, int64 ); friend bool operator >= ( int64, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, uint64 ); friend bool operator >= ( uint64, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator >= ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator >= ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator >= ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator >= ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator >= ( const sc_unsigned&, const sc_fxnum_fast& );
    friend bool operator == ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, int ); friend bool operator == ( int, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, unsigned int ); friend bool operator == ( unsigned int, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, long ); friend bool operator == ( long, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, unsigned long ); friend bool operator == ( unsigned long, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, double ); friend bool operator == ( double, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const char* ); friend bool operator == ( const char*, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator == ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, int64 ); friend bool operator == ( int64, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, uint64 ); friend bool operator == ( uint64, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator == ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator == ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator == ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator == ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator == ( const sc_unsigned&, const sc_fxnum_fast& );
    friend bool operator != ( const sc_fxnum_fast&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, int ); friend bool operator != ( int, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, unsigned int ); friend bool operator != ( unsigned int, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, long ); friend bool operator != ( long, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, unsigned long ); friend bool operator != ( unsigned long, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, double ); friend bool operator != ( double, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const char* ); friend bool operator != ( const char*, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_fxval_fast& ); friend bool operator != ( const sc_fxval_fast&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, int64 ); friend bool operator != ( int64, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, uint64 ); friend bool operator != ( uint64, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_int_base& ); friend bool operator != ( const sc_int_base&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_uint_base& ); friend bool operator != ( const sc_uint_base&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_signed& ); friend bool operator != ( const sc_signed&, const sc_fxnum_fast& ); friend bool operator != ( const sc_fxnum_fast&, const sc_unsigned& ); friend bool operator != ( const sc_unsigned&, const sc_fxnum_fast& );
# 1211 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    sc_fxnum_fast& operator =( int ); sc_fxnum_fast& operator =( unsigned int ); sc_fxnum_fast& operator =( long ); sc_fxnum_fast& operator =( unsigned long ); sc_fxnum_fast& operator =( double ); sc_fxnum_fast& operator =( const char* ); sc_fxnum_fast& operator =( const sc_fxval& ); sc_fxnum_fast& operator =( const sc_fxval_fast& ); sc_fxnum_fast& operator =( const sc_fxnum& ); sc_fxnum_fast& operator =( const sc_fxnum_fast& ); sc_fxnum_fast& operator =( int64 ); sc_fxnum_fast& operator =( uint64 ); sc_fxnum_fast& operator =( const sc_int_base& ); sc_fxnum_fast& operator =( const sc_uint_base& ); sc_fxnum_fast& operator =( const sc_signed& ); sc_fxnum_fast& operator =( const sc_unsigned& );

    sc_fxnum_fast& operator *=( int ); sc_fxnum_fast& operator *=( unsigned int ); sc_fxnum_fast& operator *=( long ); sc_fxnum_fast& operator *=( unsigned long ); sc_fxnum_fast& operator *=( double ); sc_fxnum_fast& operator *=( const char* ); sc_fxnum_fast& operator *=( const sc_fxval& ); sc_fxnum_fast& operator *=( const sc_fxval_fast& ); sc_fxnum_fast& operator *=( const sc_fxnum& ); sc_fxnum_fast& operator *=( const sc_fxnum_fast& ); sc_fxnum_fast& operator *=( int64 ); sc_fxnum_fast& operator *=( uint64 ); sc_fxnum_fast& operator *=( const sc_int_base& ); sc_fxnum_fast& operator *=( const sc_uint_base& ); sc_fxnum_fast& operator *=( const sc_signed& ); sc_fxnum_fast& operator *=( const sc_unsigned& );
    sc_fxnum_fast& operator /=( int ); sc_fxnum_fast& operator /=( unsigned int ); sc_fxnum_fast& operator /=( long ); sc_fxnum_fast& operator /=( unsigned long ); sc_fxnum_fast& operator /=( double ); sc_fxnum_fast& operator /=( const char* ); sc_fxnum_fast& operator /=( const sc_fxval& ); sc_fxnum_fast& operator /=( const sc_fxval_fast& ); sc_fxnum_fast& operator /=( const sc_fxnum& ); sc_fxnum_fast& operator /=( const sc_fxnum_fast& ); sc_fxnum_fast& operator /=( int64 ); sc_fxnum_fast& operator /=( uint64 ); sc_fxnum_fast& operator /=( const sc_int_base& ); sc_fxnum_fast& operator /=( const sc_uint_base& ); sc_fxnum_fast& operator /=( const sc_signed& ); sc_fxnum_fast& operator /=( const sc_unsigned& );
    sc_fxnum_fast& operator +=( int ); sc_fxnum_fast& operator +=( unsigned int ); sc_fxnum_fast& operator +=( long ); sc_fxnum_fast& operator +=( unsigned long ); sc_fxnum_fast& operator +=( double ); sc_fxnum_fast& operator +=( const char* ); sc_fxnum_fast& operator +=( const sc_fxval& ); sc_fxnum_fast& operator +=( const sc_fxval_fast& ); sc_fxnum_fast& operator +=( const sc_fxnum& ); sc_fxnum_fast& operator +=( const sc_fxnum_fast& ); sc_fxnum_fast& operator +=( int64 ); sc_fxnum_fast& operator +=( uint64 ); sc_fxnum_fast& operator +=( const sc_int_base& ); sc_fxnum_fast& operator +=( const sc_uint_base& ); sc_fxnum_fast& operator +=( const sc_signed& ); sc_fxnum_fast& operator +=( const sc_unsigned& );
    sc_fxnum_fast& operator -=( int ); sc_fxnum_fast& operator -=( unsigned int ); sc_fxnum_fast& operator -=( long ); sc_fxnum_fast& operator -=( unsigned long ); sc_fxnum_fast& operator -=( double ); sc_fxnum_fast& operator -=( const char* ); sc_fxnum_fast& operator -=( const sc_fxval& ); sc_fxnum_fast& operator -=( const sc_fxval_fast& ); sc_fxnum_fast& operator -=( const sc_fxnum& ); sc_fxnum_fast& operator -=( const sc_fxnum_fast& ); sc_fxnum_fast& operator -=( int64 ); sc_fxnum_fast& operator -=( uint64 ); sc_fxnum_fast& operator -=( const sc_int_base& ); sc_fxnum_fast& operator -=( const sc_uint_base& ); sc_fxnum_fast& operator -=( const sc_signed& ); sc_fxnum_fast& operator -=( const sc_unsigned& );

    sc_fxnum_fast& operator <<=( int );
    sc_fxnum_fast& operator >>=( int );
# 1228 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
    const sc_fxval_fast operator ++ ( int );
    const sc_fxval_fast operator -- ( int );

    sc_fxnum_fast& operator ++ ();
    sc_fxnum_fast& operator -- ();




    const sc_fxnum_fast_bitref operator [] ( int ) const;
    sc_fxnum_fast_bitref operator [] ( int );

    const sc_fxnum_fast_bitref bit( int ) const;
    sc_fxnum_fast_bitref bit( int );




    const sc_fxnum_fast_subref operator () ( int, int ) const;
    sc_fxnum_fast_subref operator () ( int, int );

    const sc_fxnum_fast_subref range( int, int ) const;
    sc_fxnum_fast_subref range( int, int );


    const sc_fxnum_fast_subref operator () () const;
    sc_fxnum_fast_subref operator () ();

    const sc_fxnum_fast_subref range() const;
    sc_fxnum_fast_subref range();




    operator double() const;




    short to_short() const;
    unsigned short to_ushort() const;
    int to_int() const;
    unsigned int to_uint() const;
    long to_long() const;
    unsigned long to_ulong() const;
    float to_float() const;
    double to_double() const;




    const sc_string to_string() const;
    const sc_string to_string( sc_numrep ) const;
    const sc_string to_string( sc_numrep, bool ) const;
    const sc_string to_string( sc_fmt ) const;
    const sc_string to_string( sc_numrep, sc_fmt ) const;
    const sc_string to_string( sc_numrep, bool, sc_fmt ) const;

    const sc_string to_dec() const;
    const sc_string to_bin() const;
    const sc_string to_oct() const;
    const sc_string to_hex() const;




    bool is_neg() const;
    bool is_zero() const;


    bool is_normal() const;

    bool quantization_flag() const;
    bool overflow_flag() const;

    const sc_fxval_fast value() const;




    int wl() const;
    int iwl() const;
    sc_q_mode q_mode() const;
    sc_o_mode o_mode() const;
    int n_bits() const;

    const sc_fxtype_params& type_params() const;

    const sc_fxcast_switch& cast_switch() const;




    void print( ostream& = cout ) const;
    void scan( istream& = cin );
    void dump( ostream& = cout ) const;



    void observer_read() const;



    bool get_bit( int ) const;

protected:

    bool set_bit( int, bool );


    bool get_slice( int, int, sc_bv_base& ) const;
    bool set_slice( int, int, const sc_bv_base& );


    sc_fxnum_fast_observer* lock_observer() const;
    void unlock_observer( sc_fxnum_fast_observer* ) const;

private:

    double m_val;

    scfx_params m_params;
    bool m_q_flag;
    bool m_o_flag;

    mutable sc_fxnum_fast_observer* m_observer;

private:


    sc_fxnum_fast();
    sc_fxnum_fast( const sc_fxnum_fast& );
};
# 1373 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_bitref::sc_fxnum_bitref( sc_fxnum& num_, int idx_ )
    : m_num( num_ ), m_idx( idx_ )
{}




inline
sc_fxnum_bitref::sc_fxnum_bitref( const sc_fxnum_bitref& a )
    : m_num( a.m_num ), m_idx( a.m_idx )
{}




inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator = ( const sc_fxnum_bitref& a )
{
    if( &a != this )
    {

 set( a.get() );

    }
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator = ( const sc_fxnum_fast_bitref& a )
{
   
    set( a.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator = ( const sc_bit& a )
{
    set( static_cast<bool>( a ) );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator = ( bool a )
{
    set( a );
   
    return *this;
}


inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator &= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() && b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator &= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() && b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator &= ( const sc_bit& b )
{
   
    set( get() && static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator &= ( bool b )
{
   
    set( get() && b );
   
    return *this;
}


inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator |= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() || b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator |= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() || b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator |= ( const sc_bit& b )
{
   
    set( get() || static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator |= ( bool b )
{
   
    set( get() || b );
   
    return *this;
}


inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator ^= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() != b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator ^= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() != b.get() );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator ^= ( const sc_bit& b )
{
   
    set( get() != static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_bitref&
sc_fxnum_bitref::operator ^= ( bool b )
{
   
    set( get() != b );
   
    return *this;
}




inline
sc_fxnum_bitref::operator bool() const
{
   
    return get();
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum_bitref& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum_bitref& a )
{
    a.scan( is );
    return is;
}
# 1595 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_fast_bitref::sc_fxnum_fast_bitref( sc_fxnum_fast& num_, int idx_ )
    : m_num( num_ ), m_idx( idx_ )
{}




inline
sc_fxnum_fast_bitref::sc_fxnum_fast_bitref( const sc_fxnum_fast_bitref& a )
    : m_num( a.m_num ), m_idx( a.m_idx )
{}




inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator = ( const sc_fxnum_bitref& a )
{
   
    set( a.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator = ( const sc_fxnum_fast_bitref& a )
{
    if( &a != this )
    {

 set( a.get() );

    }
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator = ( const sc_bit& a )
{
    set( static_cast<bool>( a ) );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator = ( bool a )
{
    set( a );
   
    return *this;
}


inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator &= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() && b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator &= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() && b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator &= ( const sc_bit& b )
{
   
    set( get() && static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator &= ( bool b )
{
   
    set( get() && b );
   
    return *this;
}


inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator |= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() || b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator |= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() || b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator |= ( const sc_bit& b )
{
   
    set( get() || static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator |= ( bool b )
{
   
    set( get() || b );
   
    return *this;
}


inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator ^= ( const sc_fxnum_bitref& b )
{
   
   
    set( get() != b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator ^= ( const sc_fxnum_fast_bitref& b )
{
   
   
    set( get() != b.get() );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator ^= ( const sc_bit& b )
{
   
    set( get() != static_cast<bool>( b ) );
   
    return *this;
}

inline
sc_fxnum_fast_bitref&
sc_fxnum_fast_bitref::operator ^= ( bool b )
{
   
    set( get() != b );
   
    return *this;
}




inline
sc_fxnum_fast_bitref::operator bool() const
{
   
    return get();
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum_fast_bitref& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum_fast_bitref& a )
{
    a.scan( is );
    return is;
}
# 1818 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_subref::sc_fxnum_subref( sc_fxnum& num_, int from_, int to_ )
    : m_num( num_ ), m_from( from_ ), m_to( to_ ),
      m_bv( *new sc_bv_base( sc_max( m_from, m_to ) -
        sc_min( m_from, m_to ) + 1 ) )
{}




inline
sc_fxnum_subref::sc_fxnum_subref( const sc_fxnum_subref& a )
    : m_num( a.m_num ), m_from( a.m_from ), m_to( a.m_to ),
      m_bv( *new sc_bv_base( a.m_bv ) )
{}




inline
sc_fxnum_subref::~sc_fxnum_subref()
{
    delete &m_bv;
}




inline
sc_fxnum_subref&
sc_fxnum_subref::operator = ( const sc_fxnum_subref& a )
{
    if( &a != this )
    {
 m_bv = static_cast<sc_bv_base>( a );
 set();

    }
    return *this;
}

inline
sc_fxnum_subref&
sc_fxnum_subref::operator = ( const sc_fxnum_fast_subref& a )
{
    m_bv = static_cast<sc_bv_base>( a );
    set();
   
    return *this;
}
# 1880 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_bv_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_lv_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const char* a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const bool* a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_signed& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_unsigned& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_int_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( const sc_uint_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( int64 a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( uint64 a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( int a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( unsigned int a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( long a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( unsigned long a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator = ( char a ) { m_bv = a; set(); return *this; }
# 1940 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_subref& sc_fxnum_subref::operator &= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv & static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator &= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv & static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator &= ( const sc_bv_base& a ) { get(); m_bv = m_bv & a; set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator &= ( const sc_lv_base& a ) { get(); m_bv = m_bv & a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator |= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv | static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator |= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv | static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator |= ( const sc_bv_base& a ) { get(); m_bv = m_bv | a; set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator |= ( const sc_lv_base& a ) { get(); m_bv = m_bv | a; set(); return *this; }
inline sc_fxnum_subref& sc_fxnum_subref::operator ^= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv ^ static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator ^= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv ^ static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator ^= ( const sc_bv_base& a ) { get(); m_bv = m_bv ^ a; set(); return *this; } inline sc_fxnum_subref& sc_fxnum_subref::operator ^= ( const sc_lv_base& a ) { get(); m_bv = m_bv ^ a; set(); return *this; }
# 1991 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool operator == ( const sc_fxnum_subref& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( a ) == static_cast<sc_bv_base>( b ) ); } inline bool operator == ( const sc_fxnum_subref& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( a ) == static_cast<sc_bv_base>( b ) ); } inline bool operator == ( const sc_fxnum_subref& a, const sc_bv_base& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_bv_base& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, const sc_lv_base& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_lv_base& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, const char* b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const char* a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, const bool* b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const bool* a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, const sc_signed& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_signed& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, const sc_unsigned& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_unsigned& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, int b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( int a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, unsigned int b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( unsigned int a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, long b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( long a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_subref& a, unsigned long b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( unsigned long a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); }
inline bool operator != ( const sc_fxnum_subref& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( a ) != static_cast<sc_bv_base>( b ) ); } inline bool operator != ( const sc_fxnum_subref& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( a ) != static_cast<sc_bv_base>( b ) ); } inline bool operator != ( const sc_fxnum_subref& a, const sc_bv_base& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_bv_base& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, const sc_lv_base& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_lv_base& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, const char* b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const char* a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, const bool* b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const bool* a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, const sc_signed& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_signed& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, const sc_unsigned& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_unsigned& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, int b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( int a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, unsigned int b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( unsigned int a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, long b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( long a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_subref& a, unsigned long b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( unsigned long a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); }
# 2010 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool sc_fxnum_subref::and_reduce() const { get(); return static_cast<bool>( m_bv.and_reduce() ); }
inline bool sc_fxnum_subref::nand_reduce() const { get(); return static_cast<bool>( m_bv.nand_reduce() ); }
inline bool sc_fxnum_subref::or_reduce() const { get(); return static_cast<bool>( m_bv.or_reduce() ); }
inline bool sc_fxnum_subref::nor_reduce() const { get(); return static_cast<bool>( m_bv.nor_reduce() ); }
inline bool sc_fxnum_subref::xor_reduce() const { get(); return static_cast<bool>( m_bv.xor_reduce() ); }
inline bool sc_fxnum_subref::xnor_reduce() const { get(); return static_cast<bool>( m_bv.xnor_reduce() ); }






inline
int
sc_fxnum_subref::length() const
{
    return m_bv.length();
}




inline
int
sc_fxnum_subref::to_int() const
{
   
    get();
    return m_bv.to_int();
}

inline
unsigned int
sc_fxnum_subref::to_uint() const
{
   
    get();
    return m_bv.to_uint();
}

inline
long
sc_fxnum_subref::to_long() const
{
   
    get();
    return m_bv.to_long();
}

inline
unsigned long
sc_fxnum_subref::to_ulong() const
{
   
    get();
    return m_bv.to_ulong();
}
# 2088 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
const sc_string
sc_fxnum_subref::to_string() const
{
    get();
    return m_bv.to_string();
}

inline
const sc_string
sc_fxnum_subref::to_string( sc_numrep numrep ) const
{
    get();
    return m_bv.to_string( numrep );
}

inline
const sc_string
sc_fxnum_subref::to_string( sc_numrep numrep, bool w_prefix ) const
{
    get();
    return m_bv.to_string( numrep, w_prefix );
}




inline
sc_fxnum_subref::operator sc_bv_base () const
{
   
    get();
    return m_bv;
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum_subref& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum_subref& a )
{
    a.scan( is );
    return is;
}
# 2150 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_fast_subref::sc_fxnum_fast_subref( sc_fxnum_fast& num_,
         int from_, int to_ )
    : m_num( num_ ), m_from( from_ ), m_to( to_ ),
      m_bv( *new sc_bv_base( sc_max( m_from, m_to ) -
        sc_min( m_from, m_to ) + 1 ) )
{}




inline
sc_fxnum_fast_subref::sc_fxnum_fast_subref( const sc_fxnum_fast_subref& a )
    : m_num( a.m_num ), m_from( a.m_from ), m_to( a.m_to ),
      m_bv( *new sc_bv_base( a.m_bv ) )
{}




inline
sc_fxnum_fast_subref::~sc_fxnum_fast_subref()
{
    delete &m_bv;
}




inline
sc_fxnum_fast_subref&
sc_fxnum_fast_subref::operator = ( const sc_fxnum_subref& a )
{
    m_bv = static_cast<sc_bv_base>( a );
    set();
   
    return *this;
}

inline
sc_fxnum_fast_subref&
sc_fxnum_fast_subref::operator = ( const sc_fxnum_fast_subref& a )
{
    if( &a != this )
    {
 m_bv = static_cast<sc_bv_base>( a );
 set();

    }
    return *this;
}
# 2213 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_bv_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_lv_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const char* a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const bool* a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_signed& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_unsigned& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_int_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( const sc_uint_base& a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( int64 a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( uint64 a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( int a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( unsigned int a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( long a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( unsigned long a ) { m_bv = a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator = ( char a ) { m_bv = a; set(); return *this; }
# 2273 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator &= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv & static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator &= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv & static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator &= ( const sc_bv_base& a ) { get(); m_bv = m_bv & a; set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator &= ( const sc_lv_base& a ) { get(); m_bv = m_bv & a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator |= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv | static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator |= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv | static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator |= ( const sc_bv_base& a ) { get(); m_bv = m_bv | a; set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator |= ( const sc_lv_base& a ) { get(); m_bv = m_bv | a; set(); return *this; }
inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator ^= ( const sc_fxnum_subref& a ) { get(); m_bv = m_bv ^ static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator ^= ( const sc_fxnum_fast_subref& a ) { get(); m_bv = m_bv ^ static_cast<sc_bv_base>( a ); set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator ^= ( const sc_bv_base& a ) { get(); m_bv = m_bv ^ a; set(); return *this; } inline sc_fxnum_fast_subref& sc_fxnum_fast_subref::operator ^= ( const sc_lv_base& a ) { get(); m_bv = m_bv ^ a; set(); return *this; }
# 2324 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( a ) == static_cast<sc_bv_base>( b ) ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( a ) == static_cast<sc_bv_base>( b ) ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_bv_base& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_bv_base& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_lv_base& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_lv_base& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const char* b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const char* a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const bool* b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const bool* a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_signed& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_signed& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, const sc_unsigned& b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( const sc_unsigned& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, int b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( int a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, unsigned int b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( unsigned int a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, long b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( long a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); } inline bool operator == ( const sc_fxnum_fast_subref& a, unsigned long b ) { return ( static_cast<sc_bv_base>( a ) == b ); } inline bool operator == ( unsigned long a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) == a ); }
inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( a ) != static_cast<sc_bv_base>( b ) ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_fxnum_subref& b ) { return ( static_cast<sc_bv_base>( a ) != static_cast<sc_bv_base>( b ) ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_bv_base& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_bv_base& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_lv_base& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_lv_base& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const char* b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const char* a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const bool* b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const bool* a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_signed& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_signed& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, const sc_unsigned& b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( const sc_unsigned& a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, int b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( int a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, unsigned int b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( unsigned int a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, long b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( long a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); } inline bool operator != ( const sc_fxnum_fast_subref& a, unsigned long b ) { return ( static_cast<sc_bv_base>( a ) != b ); } inline bool operator != ( unsigned long a, const sc_fxnum_fast_subref& b ) { return ( static_cast<sc_bv_base>( b ) != a ); }
# 2343 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool sc_fxnum_fast_subref::and_reduce() const { get(); return static_cast<bool>( m_bv.and_reduce() ); }
inline bool sc_fxnum_fast_subref::nand_reduce() const { get(); return static_cast<bool>( m_bv.nand_reduce() ); }
inline bool sc_fxnum_fast_subref::or_reduce() const { get(); return static_cast<bool>( m_bv.or_reduce() ); }
inline bool sc_fxnum_fast_subref::nor_reduce() const { get(); return static_cast<bool>( m_bv.nor_reduce() ); }
inline bool sc_fxnum_fast_subref::xor_reduce() const { get(); return static_cast<bool>( m_bv.xor_reduce() ); }
inline bool sc_fxnum_fast_subref::xnor_reduce() const { get(); return static_cast<bool>( m_bv.xnor_reduce() ); }






inline
int
sc_fxnum_fast_subref::length() const
{
    return m_bv.length();
}




inline
int
sc_fxnum_fast_subref::to_int() const
{
   
    get();
    return m_bv.to_int();
}

inline
unsigned int
sc_fxnum_fast_subref::to_uint() const
{
   
    get();
    return m_bv.to_uint();
}

inline
long
sc_fxnum_fast_subref::to_long() const
{
   
    get();
    return m_bv.to_long();
}

inline
unsigned long
sc_fxnum_fast_subref::to_ulong() const
{
   
    get();
    return m_bv.to_ulong();
}
# 2421 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
const sc_string
sc_fxnum_fast_subref::to_string() const
{
    get();
    return m_bv.to_string();
}

inline
const sc_string
sc_fxnum_fast_subref::to_string( sc_numrep numrep ) const
{
    get();
    return m_bv.to_string( numrep );
}

inline
const sc_string
sc_fxnum_fast_subref::to_string( sc_numrep numrep, bool w_prefix ) const
{
    get();
    return m_bv.to_string( numrep, w_prefix );
}




inline
sc_fxnum_fast_subref::operator sc_bv_base () const
{
   
    get();
    return m_bv;
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum_fast_subref& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum_fast_subref& a )
{
    a.scan( is );
    return is;
}
# 2480 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_observer*
sc_fxnum::observer() const
{
    return m_observer;
}


inline
void
sc_fxnum::cast()
{
    { if( ! m_rep->is_normal() ) sc_report_handler::report( SC_ERROR, SC_ID_INVALID_FX_VALUE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 2492 ); };

    if( m_params.cast_switch() == SC_ON )
 m_rep->cast( m_params, m_q_flag, m_o_flag );
}




inline
sc_fxnum::sc_fxnum( const sc_fxtype_params& type_params_,
      sc_enc enc_,
      const sc_fxcast_switch& cast_sw,
      sc_fxnum_observer* observer_ )
: m_rep( new scfx_rep ),
  m_params( type_params_, enc_, cast_sw ),
  m_q_flag( false ),
  m_o_flag( false ),
  m_observer( observer_ )
{
   
   
}
# 2540 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum::sc_fxnum( int a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( unsigned int a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( long a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( unsigned long a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( double a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const char* a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_fxval& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( *a.m_rep ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_fxval_fast& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a.to_double() ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_fxnum& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( *a.m_rep ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_fxnum_fast& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a.to_double() ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }

inline sc_fxnum::sc_fxnum( int64 a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( uint64 a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_int_base& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a.value() ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_uint_base& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a.value() ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_signed& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum::sc_fxnum( const sc_unsigned& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : m_rep( new scfx_rep( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
# 2566 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum::~sc_fxnum()
{
   
    delete m_rep;
}



inline
const scfx_rep*
sc_fxnum::get_rep() const
{
   
    return m_rep;
}




inline
const sc_fxval
sc_fxnum::operator - () const
{
   
    return sc_fxval( sc_dt::neg_scfx_rep( *m_rep ) );
}

inline
const sc_fxval
sc_fxnum::operator + () const
{
   
    return sc_fxval( new scfx_rep( *m_rep ) );
}




inline
void
neg( sc_fxval& c, const sc_fxnum& a )
{
   
    c.set_rep( sc_dt::neg_scfx_rep( *a.m_rep ) );
}

inline
void
neg( sc_fxnum& c, const sc_fxnum& a )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::neg_scfx_rep( *a.m_rep );
    c.cast();
   
}
# 2694 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline const sc_fxval operator * ( const sc_fxnum& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_fxval& b ) { return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline const sc_fxval operator * ( const sc_fxval& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::mult_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator * ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator + ( const sc_fxnum& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_fxval& b ) { return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline const sc_fxval operator + ( const sc_fxval& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::add_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator + ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator - ( const sc_fxnum& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_fxval& b ) { return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline const sc_fxval operator - ( const sc_fxval& a, const sc_fxnum& b ) { return sc_fxval( sc_dt::sub_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator - ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }


inline
const sc_fxval
operator / ( const sc_fxnum& a, const sc_fxnum& b )
{
   
   
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) );
}

inline
const sc_fxval
operator / ( const sc_fxnum& a, const sc_fxval& b )
{
   
    return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *b.get_rep() ) );
}

inline
const sc_fxval
operator / ( const sc_fxval& a, const sc_fxnum& b )
{
   
    return sc_fxval( sc_dt::div_scfx_rep( *a.get_rep(), *b.m_rep ) );
}

inline const sc_fxval operator / ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }


inline const sc_fxval operator / ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }
inline const sc_fxval operator / ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline const sc_fxval operator / ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); }







inline
const sc_fxval
operator << ( const sc_fxnum& a, int b )
{
   
    return sc_fxval( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
}

inline
const sc_fxval
operator >> ( const sc_fxnum& a, int b )
{
   
    return sc_fxval( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
}
# 2891 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum& b ) { c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_fxval& b ) { c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_fxnum& b ) { c.set_rep( sc_dt::mult_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *b.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_fxval& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void mult ( sc_fxval& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void mult ( sc_fxval& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void mult ( sc_fxnum& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void mult ( sc_fxnum& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); }
inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum& b ) { c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_fxval& b ) { c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_fxval& a, const sc_fxnum& b ) { c.set_rep( sc_dt::div_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *b.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_fxval& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void div ( sc_fxval& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void div ( sc_fxval& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void div ( sc_fxnum& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void div ( sc_fxnum& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); }
inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum& b ) { c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_fxval& b ) { c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_fxval& a, const sc_fxnum& b ) { c.set_rep( sc_dt::add_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *b.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_fxval& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void add ( sc_fxval& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void add ( sc_fxval& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void add ( sc_fxnum& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void add ( sc_fxnum& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); }
inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum& b ) { c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_fxval& b ) { c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *b.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_fxnum& b ) { c.set_rep( sc_dt::sub_scfx_rep( *a.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval& b ) { delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *b.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_fxval& a, const sc_fxnum& b ) { delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, double b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, double a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); } inline void sub ( sc_fxval& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); c.set_rep( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ) ); } inline void sub ( sc_fxval& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); c.set_rep( sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ) ); } inline void sub ( sc_fxnum& c, const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.get_rep() ); c.cast(); } inline void sub ( sc_fxnum& c, const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.get_rep(), *b.m_rep ); c.cast(); }






inline
void
lshift( sc_fxval& c, const sc_fxnum& a, int b )
{
   
    c.set_rep( sc_dt::lsh_scfx_rep( *a.m_rep, b ) );
}

inline
void
rshift( sc_fxval& c, const sc_fxnum& a, int b )
{
   
    c.set_rep( sc_dt::rsh_scfx_rep( *a.m_rep, b ) );
}

inline
void
lshift( sc_fxnum& c, const sc_fxnum& a, int b )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::lsh_scfx_rep( *a.m_rep, b );
    c.cast();
   
}

inline
void
rshift( sc_fxnum& c, const sc_fxnum& a, int b )
{
   
    delete c.m_rep;
    c.m_rep = sc_dt::rsh_scfx_rep( *a.m_rep, b );
    c.cast();
   
}
# 3014 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool operator < ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result < 0 ); } inline bool operator < ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result < 0 ); }
inline bool operator <= ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result <= 0 ); } inline bool operator <= ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result <= 0 ); }
inline bool operator > ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result > 0 && result != 2 ); }
inline bool operator >= ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result >= 0 && result != 2 ); }
inline bool operator == ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result == 0 ); } inline bool operator == ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result == 0 ); }
inline bool operator != ( const sc_fxnum& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_fxval& b ) { int result = sc_dt::cmp_scfx_rep( *a.m_rep, *b.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_fxval& a, const sc_fxnum& b ) { int result = sc_dt::cmp_scfx_rep( *a.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, unsigned int b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( unsigned int a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, unsigned long b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( unsigned long a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, double b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( double a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const char* b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const char* a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, int64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( int64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, uint64 b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( uint64 a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_int_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_int_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_uint_base& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_uint_base& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_signed& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_signed& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum& a, const sc_unsigned& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.get_rep() ); return ( result != 0 ); } inline bool operator != ( const sc_unsigned& a, const sc_fxnum& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.get_rep(), *b.m_rep ); return ( result != 0 ); }
# 3028 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum&
sc_fxnum::operator = ( const sc_fxnum& a )
{
    if( &a != this )
    {
       
 *m_rep = *a.m_rep;
 cast();

    }
    return *this;
}

inline
sc_fxnum&
sc_fxnum::operator = ( const sc_fxval& a )
{
    *m_rep = *a.get_rep();
    cast();
   
    return *this;
}
# 3064 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum& sc_fxnum::operator = ( int a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( unsigned int a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( long a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( unsigned long a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( double a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const char* a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_fxval_fast& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_fxnum_fast& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }

inline sc_fxnum& sc_fxnum::operator = ( int64 a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( uint64 a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_int_base& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_uint_base& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_signed& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator = ( const sc_unsigned& a ) { sc_fxval tmp( a ); *m_rep = *tmp.get_rep(); cast(); return *this; }
# 3149 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum& sc_fxnum::operator *= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator *= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator /= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator /= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator += ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator += ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; }
inline sc_fxnum& sc_fxnum::operator -= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *b.m_rep ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_fxval& b ) { scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( unsigned int b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( unsigned long b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( double b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const char* b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_fxval_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( int64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( uint64 b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_int_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_uint_base& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_signed& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; } inline sc_fxnum& sc_fxnum::operator -= ( const sc_unsigned& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.get_rep() ); delete m_rep; m_rep = new_rep; cast(); return *this; }






inline
sc_fxnum&
sc_fxnum::operator <<= ( int b )
{
   
    m_rep->lshift( b );
    cast();
   
    return *this;
}

inline
sc_fxnum&
sc_fxnum::operator >>= ( int b )
{
   
    m_rep->rshift( b );
    cast();
   
    return *this;
}




inline
const sc_fxval
sc_fxnum::operator ++ ( int )
{
    sc_fxval c( *this );
    (*this) += 1;
    return c;
}

inline
const sc_fxval
sc_fxnum::operator -- ( int )
{
    sc_fxval c( *this );
    (*this) -= 1;
    return c;
}

inline
sc_fxnum&
sc_fxnum::operator ++ ()
{
    (*this) += 1;
    return *this;
}

inline
sc_fxnum&
sc_fxnum::operator -- ()
{
    (*this) -= 1;
    return *this;
}




inline
const sc_fxnum_bitref
sc_fxnum::operator [] ( int i ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3225 ); };
    return sc_fxnum_bitref( const_cast<sc_fxnum&>( *this ),
       i - m_params.fwl() );
}

inline
sc_fxnum_bitref
sc_fxnum::operator [] ( int i )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3234 ); };
    return sc_fxnum_bitref( *this, i - m_params.fwl() );
}

inline
const sc_fxnum_bitref
sc_fxnum::bit( int i ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3242 ); };
    return sc_fxnum_bitref( const_cast<sc_fxnum&>( *this ),
       i - m_params.fwl() );
}

inline
sc_fxnum_bitref
sc_fxnum::bit( int i )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3251 ); };
    return sc_fxnum_bitref( *this, i - m_params.fwl() );
}




inline
const sc_fxnum_subref
sc_fxnum::operator () ( int i, int j ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3262 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3263 ); };

    return sc_fxnum_subref( const_cast<sc_fxnum&>( *this ),
       i - m_params.fwl(), j - m_params.fwl() );
}

inline
sc_fxnum_subref
sc_fxnum::operator () ( int i, int j )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3273 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3274 ); };

    return sc_fxnum_subref( *this, i - m_params.fwl(), j - m_params.fwl() );
}

inline
const sc_fxnum_subref
sc_fxnum::range( int i, int j ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3283 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3284 ); };

    return sc_fxnum_subref( const_cast<sc_fxnum&>( *this ),
       i - m_params.fwl(), j - m_params.fwl() );
}

inline
sc_fxnum_subref
sc_fxnum::range( int i, int j )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3294 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 3295 ); };

    return sc_fxnum_subref( *this, i - m_params.fwl(), j - m_params.fwl() );
}


inline
const sc_fxnum_subref
sc_fxnum::operator () () const
{
    return this->operator () ( m_params.wl() - 1, 0 );
}

inline
sc_fxnum_subref
sc_fxnum::operator () ()
{
    return this->operator () ( m_params.wl() - 1, 0 );
}

inline
const sc_fxnum_subref
sc_fxnum::range() const
{
    return this->range( m_params.wl() - 1, 0 );
}

inline
sc_fxnum_subref
sc_fxnum::range()
{
    return this->range( m_params.wl() - 1, 0 );
}




inline
sc_fxnum::operator double() const
{
   
    return m_rep->to_double();
}




inline
short
sc_fxnum::to_short() const
{
   
    return static_cast<short>( m_rep->to_double() );
}

inline
unsigned short
sc_fxnum::to_ushort() const
{
   
    return static_cast<unsigned short>( m_rep->to_double() );
}

inline
int
sc_fxnum::to_int() const
{
   
    return static_cast<int>( m_rep->to_double() );
}

inline
unsigned int
sc_fxnum::to_uint() const
{
   
    return static_cast<unsigned int>( m_rep->to_double() );
}

inline
long
sc_fxnum::to_long() const
{
   
    return static_cast<long>( m_rep->to_double() );
}

inline
unsigned long
sc_fxnum::to_ulong() const
{
   
    return static_cast<unsigned long>( m_rep->to_double() );
}

inline
float
sc_fxnum::to_float() const
{
   
    return static_cast<float>( m_rep->to_double() );
}

inline
double
sc_fxnum::to_double() const
{
   
    return m_rep->to_double();
}




inline
bool
sc_fxnum::is_neg() const
{
   
    return m_rep->is_neg();
}

inline
bool
sc_fxnum::is_zero() const
{
   
    return m_rep->is_zero();
}


inline
bool
sc_fxnum::is_normal() const
{
   
    return m_rep->is_normal();
}

inline
bool
sc_fxnum::quantization_flag() const
{
    return m_q_flag;
}

inline
bool
sc_fxnum::overflow_flag() const
{
    return m_o_flag;
}


inline
const sc_fxval
sc_fxnum::value() const
{
   
    return sc_fxval( new scfx_rep( *m_rep ) );
}




inline
int
sc_fxnum::wl() const
{
    return m_params.wl();
}

inline
int
sc_fxnum::iwl() const
{
    return m_params.iwl();
}

inline
sc_q_mode
sc_fxnum::q_mode() const
{
    return m_params.q_mode();
}

inline
sc_o_mode
sc_fxnum::o_mode() const
{
    return m_params.o_mode();
}

inline
int
sc_fxnum::n_bits() const
{
    return m_params.n_bits();
}


inline
const sc_fxtype_params&
sc_fxnum::type_params() const
{
    return m_params.type_params();
}


inline
const sc_fxcast_switch&
sc_fxnum::cast_switch() const
{
    return m_params.cast_switch();
}



inline
void
sc_fxnum::observer_read() const
{
    ;
}



inline
bool
sc_fxnum::get_bit( int i ) const
{
    return m_rep->get_bit( i );
}




inline
bool
sc_fxnum::set_bit( int i, bool high )
{
    if( high )
        return m_rep->set( i, m_params );
    else
        return m_rep->clear( i, m_params );
}


inline
bool
sc_fxnum::get_slice( int i, int j, sc_bv_base& bv ) const
{
    return m_rep->get_slice( i, j, m_params, bv );
}

inline
bool
sc_fxnum::set_slice( int i, int j, const sc_bv_base& bv )
{
    return m_rep->set_slice( i, j, m_params, bv );
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum& a )
{
    a.scan( is );
    return is;
}
# 3581 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_fast_observer*
sc_fxnum_fast::observer() const
{
    return m_observer;
}




inline
sc_fxnum_fast::sc_fxnum_fast( const sc_fxtype_params& type_params_,
         sc_enc enc_,
         const sc_fxcast_switch& cast_sw,
         sc_fxnum_fast_observer* observer_ )
: m_val( 0.0 ),
  m_params( type_params_, enc_, cast_sw ),
  m_q_flag( false ),
  m_o_flag( false ),
  m_observer( observer_ )
{
   
   
}

inline
sc_fxnum_fast::sc_fxnum_fast( const sc_fxnum_fast& a,
         const sc_fxtype_params& type_params_,
         sc_enc enc_,
         const sc_fxcast_switch& cast_sw,
         sc_fxnum_fast_observer* observer_ )
: m_val( a.m_val ),
  m_params( type_params_, enc_, cast_sw ),
  m_q_flag( false ),
  m_o_flag( false ),
  m_observer( observer_ )
{
   
   
    cast();
   
   
}
# 3648 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_fast::sc_fxnum_fast( int a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( unsigned int a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( long a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( unsigned long a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( double a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const char* a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( sc_fxval_fast::from_string( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_fxval& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_fxval_fast& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_fxnum& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }

inline sc_fxnum_fast::sc_fxnum_fast( int64 a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( uint64 a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( static_cast<double>( a ) ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_int_base& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_uint_base& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_signed& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
inline sc_fxnum_fast::sc_fxnum_fast( const sc_unsigned& a, const sc_fxtype_params& type_params_, sc_enc enc_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : m_val( a.to_double() ), m_params( type_params_, enc_, cast_sw ), m_q_flag( false ), m_o_flag( false ), m_observer( observer_ ) { cast(); }
# 3674 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_fast::~sc_fxnum_fast()
{
   
}



inline
double
sc_fxnum_fast::get_val() const
{
   
    return m_val;
}




inline
const sc_fxval_fast
sc_fxnum_fast::operator - () const
{
   
    return sc_fxval_fast( - m_val );
}

inline
const sc_fxval_fast
sc_fxnum_fast::operator + () const
{
   
    return sc_fxval_fast( m_val );
}




inline
void
neg( sc_fxval_fast& c, const sc_fxnum_fast& a )
{
   
    c.set_val( - a.m_val );
}

inline
void
neg( sc_fxnum_fast& c, const sc_fxnum_fast& a )
{
   
    c.m_val = - a.m_val;
    c.cast();
   
}
# 3798 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.m_val * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val * b.get_val() ); } inline const sc_fxval_fast operator * ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); } inline const sc_fxval_fast operator * ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val * tmp.get_val() ); } inline const sc_fxval_fast operator * ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() * b.m_val ); }
inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.m_val + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val + b.get_val() ); } inline const sc_fxval_fast operator + ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); } inline const sc_fxval_fast operator + ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val + tmp.get_val() ); } inline const sc_fxval_fast operator + ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() + b.m_val ); }
inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.m_val - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return sc_fxval_fast( a.m_val - b.get_val() ); } inline const sc_fxval_fast operator - ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return sc_fxval_fast( a.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); } inline const sc_fxval_fast operator - ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val - tmp.get_val() ); } inline const sc_fxval_fast operator - ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() - b.m_val ); }

inline
const sc_fxval_fast
operator / ( const sc_fxnum_fast& a, const sc_fxnum_fast& b )
{
   
   
    return sc_fxval_fast( a.m_val / b.m_val );
}

inline
const sc_fxval_fast
operator / ( const sc_fxnum_fast& a, const sc_fxval_fast& b )
{
   
    return sc_fxval_fast( a.m_val / b.get_val() );
}

inline
const sc_fxval_fast
operator / ( const sc_fxval_fast& a, const sc_fxnum_fast& b )
{
   
    return sc_fxval_fast( a.get_val() / b.m_val );
}

inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }


inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }
inline const sc_fxval_fast operator / ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return sc_fxval_fast( a.m_val / tmp.get_val() ); } inline const sc_fxval_fast operator / ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return sc_fxval_fast( tmp.get_val() / b.m_val ); }







inline
const sc_fxval_fast
operator << ( const sc_fxnum_fast& a, int b )
{
   
    return sc_fxval_fast( a.m_val * scfx_pow2( b ) );
}

inline
const sc_fxval_fast
operator >> ( const sc_fxnum_fast& a, int b )
{
   
    return sc_fxval_fast( a.m_val * scfx_pow2( -b ) );
}
# 3987 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.m_val * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.m_val * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.set_val( a.m_val * b.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val * b.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); } inline void mult ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val * tmp.get_val() ); } inline void mult ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() * b.m_val ); } inline void mult ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.get_val(); c.cast(); } inline void mult ( sc_fxnum_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() * b.m_val; c.cast(); }
inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.m_val / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.m_val / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.set_val( a.m_val / b.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val / b.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); } inline void div ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val / tmp.get_val() ); } inline void div ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() / b.m_val ); } inline void div ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.get_val(); c.cast(); } inline void div ( sc_fxnum_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() / b.m_val; c.cast(); }
inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.m_val + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.m_val + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.set_val( a.m_val + b.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val + b.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); } inline void add ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val + tmp.get_val() ); } inline void add ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() + b.m_val ); } inline void add ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.get_val(); c.cast(); } inline void add ( sc_fxnum_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() + b.m_val; c.cast(); }
inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.m_val - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.m_val - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.set_val( a.m_val - b.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.set_val( a.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval_fast& b ) { c.m_val = a.m_val - b.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_fxval_fast& a, const sc_fxnum_fast& b ) { c.m_val = a.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); } inline void sub ( sc_fxval_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.set_val( a.m_val - tmp.get_val() ); } inline void sub ( sc_fxval_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.set_val( tmp.get_val() - b.m_val ); } inline void sub ( sc_fxnum_fast& c, const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.get_val(); c.cast(); } inline void sub ( sc_fxnum_fast& c, const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.get_val() - b.m_val; c.cast(); }






inline
void
lshift( sc_fxval_fast& c, const sc_fxnum_fast& a, int b )
{
   
    c.set_val( a.m_val * scfx_pow2( b ) );
}

inline
void
rshift( sc_fxval_fast& c, const sc_fxnum_fast& a, int b )
{
   
    c.set_val( a.m_val * scfx_pow2( -b ) );
}

inline
void
lshift( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b )
{
   
    c.m_val = a.m_val * scfx_pow2( b );
    c.cast();
   
}

inline
void
rshift( sc_fxnum_fast& c, const sc_fxnum_fast& a, int b )
{
   
    c.m_val = a.m_val * scfx_pow2( -b );
    c.cast();
   
}
# 4101 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool operator < ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val < b.get_val() ); } inline bool operator < ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val < tmp.get_val() ); } inline bool operator < ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() < b.m_val ); }
inline bool operator <= ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val <= b.get_val() ); } inline bool operator <= ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val <= tmp.get_val() ); } inline bool operator <= ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() <= b.m_val ); }
inline bool operator > ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val > b.get_val() ); } inline bool operator > ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val > tmp.get_val() ); } inline bool operator > ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() > b.m_val ); }
inline bool operator >= ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val >= b.get_val() ); } inline bool operator >= ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val >= tmp.get_val() ); } inline bool operator >= ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() >= b.m_val ); }
inline bool operator == ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val == b.get_val() ); } inline bool operator == ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val == tmp.get_val() ); } inline bool operator == ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() == b.m_val ); }
inline bool operator != ( const sc_fxnum_fast& a, const sc_fxnum_fast& b ) { return ( a.m_val != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_fxval_fast& b ) { return ( a.m_val != b.get_val() ); } inline bool operator != ( const sc_fxval_fast& a, const sc_fxnum_fast& b ) { return ( a.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, int b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, unsigned int b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( unsigned int a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, long b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, unsigned long b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( unsigned long a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, double b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( double a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const char* b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( const char* a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, int64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( int64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, uint64 b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( uint64 a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_int_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( const sc_int_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_uint_base& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( const sc_uint_base& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_signed& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( const sc_signed& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_unsigned& b ) { sc_fxval_fast tmp( b ); return ( a.m_val != tmp.get_val() ); } inline bool operator != ( const sc_unsigned& a, const sc_fxnum_fast& b ) { sc_fxval_fast tmp( a ); return ( tmp.get_val() != b.m_val ); }
# 4115 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxnum_fast&
sc_fxnum_fast::operator = ( const sc_fxnum_fast& a )
{
    if( &a != this )
    {

 m_val = a.m_val;
 cast();

    }
    return *this;
}

inline
sc_fxnum_fast&
sc_fxnum_fast::operator = ( const sc_fxval_fast& a )
{
    m_val = a.get_val();
    cast();
   
    return *this;
}
# 4151 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( int a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( unsigned int a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( long a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( unsigned long a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( double a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const char* a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_fxval& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_fxnum& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }

inline sc_fxnum_fast& sc_fxnum_fast::operator = ( int64 a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( uint64 a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_int_base& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_uint_base& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_signed& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator = ( const sc_unsigned& a ) { sc_fxval_fast tmp( a ); m_val = tmp.get_val(); cast(); return *this; }
# 4230 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_fxnum_fast& b ) { m_val *= b.m_val; cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_fxval_fast& b ) { m_val *= b.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( int b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( long b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( double b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const char* b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( int64 b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator *= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_fxnum_fast& b ) { m_val /= b.m_val; cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_fxval_fast& b ) { m_val /= b.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( int b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( long b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( double b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const char* b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( int64 b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator /= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_fxnum_fast& b ) { m_val += b.m_val; cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_fxval_fast& b ) { m_val += b.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( int b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( long b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( double b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const char* b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( int64 b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( uint64 b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator += ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val += tmp.get_val(); cast(); return *this; }
inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_fxnum_fast& b ) { m_val -= b.m_val; cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_fxval_fast& b ) { m_val -= b.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( int b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( unsigned int b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( long b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( unsigned long b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( double b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const char* b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_fxval& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( int64 b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( uint64 b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_int_base& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_uint_base& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_signed& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; } inline sc_fxnum_fast& sc_fxnum_fast::operator -= ( const sc_unsigned& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.get_val(); cast(); return *this; }






inline
sc_fxnum_fast&
sc_fxnum_fast::operator <<= ( int b )
{
   
    m_val *= scfx_pow2( b );
    cast();
   
    return *this;
}

inline
sc_fxnum_fast&
sc_fxnum_fast::operator >>= ( int b )
{
   
    m_val *= scfx_pow2( -b );
    cast();
   
    return *this;
}




inline
const sc_fxval_fast
sc_fxnum_fast::operator ++ ( int )
{
   
   
    double c = m_val;
    m_val = m_val + 1;
    cast();
   
    return sc_fxval_fast( c );
}

inline
const sc_fxval_fast
sc_fxnum_fast::operator -- ( int )
{
   
   
    double c = m_val;
    m_val = m_val - 1;
    cast();
   
    return sc_fxval_fast( c );
}

inline
sc_fxnum_fast&
sc_fxnum_fast::operator ++ ()
{
   
    m_val = m_val + 1;
    cast();
   
    return *this;
}

inline
sc_fxnum_fast&
sc_fxnum_fast::operator -- ()
{
   
    m_val = m_val - 1;
    cast();
   
    return *this;
}




inline
const sc_fxnum_fast_bitref
sc_fxnum_fast::operator [] ( int i ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4320 ); };
    return sc_fxnum_fast_bitref( const_cast<sc_fxnum_fast&>( *this ),
     i - m_params.fwl() );
}

inline
sc_fxnum_fast_bitref
sc_fxnum_fast::operator [] ( int i )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4329 ); };
    return sc_fxnum_fast_bitref( *this, i - m_params.fwl() );
}

inline
const sc_fxnum_fast_bitref
sc_fxnum_fast::bit( int i ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4337 ); };
    return sc_fxnum_fast_bitref( const_cast<sc_fxnum_fast&>( *this ),
     i - m_params.fwl() );
}

inline
sc_fxnum_fast_bitref
sc_fxnum_fast::bit( int i )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4346 ); };
    return sc_fxnum_fast_bitref( *this, i - m_params.fwl() );
}




inline
const sc_fxnum_fast_subref
sc_fxnum_fast::operator () ( int i, int j ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4357 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4358 ); };

    return sc_fxnum_fast_subref( const_cast<sc_fxnum_fast&>( *this ),
     i - m_params.fwl(), j - m_params.fwl() );
}

inline
sc_fxnum_fast_subref
sc_fxnum_fast::operator () ( int i, int j )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4368 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4369 ); };

    return sc_fxnum_fast_subref( *this,
     i - m_params.fwl(), j - m_params.fwl() );
}

inline
const sc_fxnum_fast_subref
sc_fxnum_fast::range( int i, int j ) const
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4379 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4380 ); };

    return sc_fxnum_fast_subref( const_cast<sc_fxnum_fast&>( *this ),
     i - m_params.fwl(), j - m_params.fwl() );
}

inline
sc_fxnum_fast_subref
sc_fxnum_fast::range( int i, int j )
{
    { if( i < 0 || i >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4390 ); };
    { if( j < 0 || j >= m_params.wl() ) sc_report_handler::report( SC_ERROR, SC_ID_OUT_OF_RANGE_, 0, "../../../src/systemc/datatypes/fx/sc_fxnum.h", 4391 ); };

    return sc_fxnum_fast_subref( *this,
     i - m_params.fwl(), j - m_params.fwl() );
}

inline
const sc_fxnum_fast_subref
sc_fxnum_fast::operator () () const
{
    return this->operator () ( m_params.wl() - 1, 0 );
}

inline
sc_fxnum_fast_subref
sc_fxnum_fast::operator () ()
{
    return this->operator () ( m_params.wl() - 1, 0 );
}

inline
const sc_fxnum_fast_subref
sc_fxnum_fast::range() const
{
    return this->range( m_params.wl() - 1, 0 );
}

inline
sc_fxnum_fast_subref
sc_fxnum_fast::range()
{
    return this->range( m_params.wl() - 1, 0 );
}




inline
sc_fxnum_fast::operator double() const
{
   
    return m_val;
}




inline
short
sc_fxnum_fast::to_short() const
{
   
    return static_cast<short>( m_val );
}

inline
unsigned short
sc_fxnum_fast::to_ushort() const
{
   
    return static_cast<unsigned short>( m_val );
}

inline
int
sc_fxnum_fast::to_int() const
{
   
    return static_cast<int>( m_val );
}

inline
unsigned int
sc_fxnum_fast::to_uint() const
{
   
    return static_cast<unsigned int>( m_val );
}

inline
long
sc_fxnum_fast::to_long() const
{
   
    return static_cast<long>( m_val );
}

inline
unsigned long
sc_fxnum_fast::to_ulong() const
{
   
    return static_cast<unsigned long>( m_val );
}

inline
float
sc_fxnum_fast::to_float() const
{
   
    return static_cast<float>( m_val );
}

inline
double
sc_fxnum_fast::to_double() const
{
   
    return m_val;
}




inline
bool
sc_fxnum_fast::is_neg() const
{
   
    scfx_ieee_double id( m_val );
    return ( id.negative() != 0 );
}

inline
bool
sc_fxnum_fast::is_zero() const
{
   
    scfx_ieee_double id( m_val );
    return id.is_zero();
}


inline
bool
sc_fxnum_fast::is_normal() const
{
   
    scfx_ieee_double id( m_val );
    return ( id.is_normal() || id.is_subnormal() || id.is_zero() );
}


inline
bool
sc_fxnum_fast::quantization_flag() const
{
    return m_q_flag;
}

inline
bool
sc_fxnum_fast::overflow_flag() const
{
    return m_o_flag;
}


inline
const sc_fxval_fast
sc_fxnum_fast::value() const
{
   
    return sc_fxval_fast( m_val );
}




inline
int
sc_fxnum_fast::wl() const
{
    return m_params.wl();
}

inline
int
sc_fxnum_fast::iwl() const
{
    return m_params.iwl();
}

inline
sc_q_mode
sc_fxnum_fast::q_mode() const
{
    return m_params.q_mode();
}

inline
sc_o_mode
sc_fxnum_fast::o_mode() const
{
    return m_params.o_mode();
}

inline
int
sc_fxnum_fast::n_bits() const
{
    return m_params.n_bits();
}


inline
const sc_fxtype_params&
sc_fxnum_fast::type_params() const
{
    return m_params.type_params();
}


inline
const sc_fxcast_switch&
sc_fxnum_fast::cast_switch() const
{
    return m_params.cast_switch();
}



inline
void
sc_fxnum_fast::observer_read() const
{
    ;
}


inline
ostream&
operator << ( ostream& os, const sc_fxnum_fast& a )
{
    a.print( os );
    return os;
}

inline
istream&
operator >> ( istream& is, sc_fxnum_fast& a )
{
    a.scan( is );
    return is;
}
# 4646 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxval::sc_fxval( const sc_fxnum& a,
      sc_fxval_observer* observer_ )
: m_rep( new scfx_rep( *a.get_rep() ) ),
  m_observer( observer_ )
{
   
   
   
}

inline
sc_fxval::sc_fxval( const sc_fxnum_fast& a,
      sc_fxval_observer* observer_ )
: m_rep( new scfx_rep( a.to_double() ) ),
  m_observer( observer_ )
{
   
   
   
}
# 4693 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline const sc_fxval operator * ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator * ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator + ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator + ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
inline const sc_fxval operator - ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator - ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }

inline const sc_fxval operator / ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); return sc_fxval( sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ) ); } inline const sc_fxval operator / ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); return sc_fxval( sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ) ); }
# 4731 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline void mult ( sc_fxval& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void mult ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::mult_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void div ( sc_fxval& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void div ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::div_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void add ( sc_fxval& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void add ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::add_scfx_rep( *tmp.m_rep, *b.m_rep ); }
inline void sub ( sc_fxval& c, const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *a.m_rep, *tmp.m_rep ); } inline void sub ( sc_fxval& c, const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); delete c.m_rep; c.m_rep = sc_dt::sub_scfx_rep( *tmp.m_rep, *b.m_rep ); }
# 4767 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline bool operator < ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result < 0 ); } inline bool operator < ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result < 0 ); }
inline bool operator <= ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result <= 0 ); } inline bool operator <= ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result <= 0 ); }
inline bool operator > ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result > 0 && result != 2 ); } inline bool operator > ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result > 0 && result != 2 ); }
inline bool operator >= ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result >= 0 && result != 2 ); } inline bool operator >= ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result >= 0 && result != 2 ); }
inline bool operator == ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result == 0 ); } inline bool operator == ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result == 0 ); }
inline bool operator != ( const sc_fxval& a, const sc_fxnum_fast& b ) { sc_fxval tmp( b ); int result = sc_dt::cmp_scfx_rep( *a.m_rep, *tmp.m_rep ); return ( result != 0 ); } inline bool operator != ( const sc_fxnum_fast& a, const sc_fxval& b ) { sc_fxval tmp( a ); int result = sc_dt::cmp_scfx_rep( *tmp.m_rep, *b.m_rep ); return ( result != 0 ); }







inline
sc_fxval&
sc_fxval::operator = ( const sc_fxnum& a )
{
    *m_rep = *a.get_rep();
   
    return *this;
}
# 4800 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxval& sc_fxval::operator = ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); *m_rep = *tmp.m_rep; return *this; }
# 4834 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxval& sc_fxval::operator *= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator *= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::mult_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator /= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator /= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::div_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator += ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator += ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::add_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
inline sc_fxval& sc_fxval::operator -= ( const sc_fxnum& b ) { scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *b.get_rep() ); delete m_rep; m_rep = new_rep; return *this; } inline sc_fxval& sc_fxval::operator -= ( const sc_fxnum_fast& b ) { sc_fxval tmp( b ); scfx_rep* new_rep = sc_dt::sub_scfx_rep( *m_rep, *tmp.m_rep ); delete m_rep; m_rep = new_rep; return *this; }
# 4851 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline
sc_fxval_fast::sc_fxval_fast( const sc_fxnum& a,
         sc_fxval_fast_observer* observer_ )
: m_val( a.to_double() ),
  m_observer( observer_ )
{
   
   
   
}

inline
sc_fxval_fast::sc_fxval_fast( const sc_fxnum_fast& a,
         sc_fxval_fast_observer* observer_ )
: m_val( a.get_val() ),
  m_observer( observer_ )
{
   
   
   
}
# 4901 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val * tmp.m_val; } inline void mult ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val * b.m_val; }
inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val / tmp.m_val; } inline void div ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val / b.m_val; }
inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val + tmp.m_val; } inline void add ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val + b.m_val; }
inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxval& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxval_fast& a, const sc_fxnum& b ) { sc_fxval_fast tmp( b ); c.m_val = a.m_val - tmp.m_val; } inline void sub ( sc_fxval_fast& c, const sc_fxnum& a, const sc_fxval_fast& b ) { sc_fxval_fast tmp( a ); c.m_val = tmp.m_val - b.m_val; }







inline
sc_fxval_fast&
sc_fxval_fast::operator = ( const sc_fxnum_fast& a )
{
    m_val = a.get_val();
   
    return *this;
}
# 4932 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxval_fast& sc_fxval_fast::operator = ( const sc_fxnum& a ) { sc_fxval_fast tmp( a ); m_val = tmp.m_val; return *this; }
# 4962 "../../../src/systemc/datatypes/fx/sc_fxnum.h"
inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_fxnum_fast& b ) { m_val *= b.get_val(); return *this; } inline sc_fxval_fast& sc_fxval_fast::operator *= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val *= tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_fxnum_fast& b ) { m_val /= b.get_val(); return *this; } inline sc_fxval_fast& sc_fxval_fast::operator /= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val /= tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_fxnum_fast& b ) { m_val += b.get_val(); return *this; } inline sc_fxval_fast& sc_fxval_fast::operator += ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val += tmp.m_val; return *this; }
inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_fxnum_fast& b ) { m_val -= b.get_val(); return *this; } inline sc_fxval_fast& sc_fxval_fast::operator -= ( const sc_fxnum& b ) { sc_fxval_fast tmp( b ); m_val -= tmp.m_val; return *this; }




}
# 41 "../../../src/systemc/datatypes/fx/sc_fix.h" 2


namespace sc_dt
{


class sc_fix;
class sc_fix_fast;
# 57 "../../../src/systemc/datatypes/fx/sc_fix.h"
class sc_fix : public sc_fxnum
{

public:



    explicit sc_fix( sc_fxnum_observer* = 0 );
             sc_fix( int, int,
       sc_fxnum_observer* = 0 );
             sc_fix( sc_q_mode, sc_o_mode,
       sc_fxnum_observer* = 0 );
             sc_fix( sc_q_mode, sc_o_mode, int,
       sc_fxnum_observer* = 0 );
             sc_fix( int, int, sc_q_mode, sc_o_mode,
       sc_fxnum_observer* = 0 );
             sc_fix( int, int, sc_q_mode, sc_o_mode, int,
       sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
             sc_fix( int, int,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
             sc_fix( sc_q_mode, sc_o_mode,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
             sc_fix( sc_q_mode, sc_o_mode, int,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
             sc_fix( int, int, sc_q_mode, sc_o_mode,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
             sc_fix( int, int, sc_q_mode, sc_o_mode, int,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_fxtype_params&,
       sc_fxnum_observer* = 0 );
             sc_fix( const sc_fxtype_params&,
       const sc_fxcast_switch&,
       sc_fxnum_observer* = 0 );
# 155 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix( int, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, sc_fxnum_observer* = 0 ); sc_fix( int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( int, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( unsigned int, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( unsigned int, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( long, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, sc_fxnum_observer* = 0 ); sc_fix( long, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( long, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( long, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( long, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( long, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( unsigned long, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( unsigned long, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( double, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, sc_fxnum_observer* = 0 ); sc_fix( double, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( double, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( double, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( double, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( double, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( const char*, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, sc_fxnum_observer* = 0 ); sc_fix( const char*, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const char*, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const char*, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const char*, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const char*, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( const sc_fxval&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( const sc_fxval_fast&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxval_fast&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( const sc_fxnum&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fix( const sc_fxnum_fast&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_fxnum_fast&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );

    explicit sc_fix( int64, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, sc_fxnum_observer* = 0 ); sc_fix( int64, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( int64, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( int64, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( int64, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( int64, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fix( uint64, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, sc_fxnum_observer* = 0 ); sc_fix( uint64, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( uint64, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( uint64, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( uint64, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( uint64, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_int_base&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_int_base&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_uint_base&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_uint_base&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_signed&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_signed&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fix( const sc_unsigned&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, const sc_fxtype_params&, sc_fxnum_observer* = 0 ); sc_fix( const sc_unsigned&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
# 180 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix( const sc_fix& );




    const sc_fix operator ~ () const;




    friend void b_not( sc_fix&, const sc_fix& );




    friend const sc_fix operator & ( const sc_fix&, const sc_fix& );
    friend const sc_fix operator & ( const sc_fix&, const sc_fix_fast& );
    friend const sc_fix operator & ( const sc_fix_fast&, const sc_fix& );
    friend const sc_fix operator | ( const sc_fix&, const sc_fix& );
    friend const sc_fix operator | ( const sc_fix&, const sc_fix_fast& );
    friend const sc_fix operator | ( const sc_fix_fast&, const sc_fix& );
    friend const sc_fix operator ^ ( const sc_fix&, const sc_fix& );
    friend const sc_fix operator ^ ( const sc_fix&, const sc_fix_fast& );
    friend const sc_fix operator ^ ( const sc_fix_fast&, const sc_fix& );




    friend void b_and( sc_fix&, const sc_fix&, const sc_fix& );
    friend void b_and( sc_fix&, const sc_fix&, const sc_fix_fast& );
    friend void b_and( sc_fix&, const sc_fix_fast&, const sc_fix& );
    friend void b_or ( sc_fix&, const sc_fix&, const sc_fix& );
    friend void b_or ( sc_fix&, const sc_fix&, const sc_fix_fast& );
    friend void b_or ( sc_fix&, const sc_fix_fast&, const sc_fix& );
    friend void b_xor( sc_fix&, const sc_fix&, const sc_fix& );
    friend void b_xor( sc_fix&, const sc_fix&, const sc_fix_fast& );
    friend void b_xor( sc_fix&, const sc_fix_fast&, const sc_fix& );




    sc_fix& operator = ( const sc_fix& );
# 251 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix& operator = ( int ); sc_fix& operator = ( unsigned int ); sc_fix& operator = ( long ); sc_fix& operator = ( unsigned long ); sc_fix& operator = ( double ); sc_fix& operator = ( const char* ); sc_fix& operator = ( const sc_fxval& ); sc_fix& operator = ( const sc_fxval_fast& ); sc_fix& operator = ( const sc_fxnum& ); sc_fix& operator = ( const sc_fxnum_fast& ); sc_fix& operator = ( int64 ); sc_fix& operator = ( uint64 ); sc_fix& operator = ( const sc_int_base& ); sc_fix& operator = ( const sc_uint_base& ); sc_fix& operator = ( const sc_signed& ); sc_fix& operator = ( const sc_unsigned& );

    sc_fix& operator *= ( int ); sc_fix& operator *= ( unsigned int ); sc_fix& operator *= ( long ); sc_fix& operator *= ( unsigned long ); sc_fix& operator *= ( double ); sc_fix& operator *= ( const char* ); sc_fix& operator *= ( const sc_fxval& ); sc_fix& operator *= ( const sc_fxval_fast& ); sc_fix& operator *= ( const sc_fxnum& ); sc_fix& operator *= ( const sc_fxnum_fast& ); sc_fix& operator *= ( int64 ); sc_fix& operator *= ( uint64 ); sc_fix& operator *= ( const sc_int_base& ); sc_fix& operator *= ( const sc_uint_base& ); sc_fix& operator *= ( const sc_signed& ); sc_fix& operator *= ( const sc_unsigned& );
    sc_fix& operator /= ( int ); sc_fix& operator /= ( unsigned int ); sc_fix& operator /= ( long ); sc_fix& operator /= ( unsigned long ); sc_fix& operator /= ( double ); sc_fix& operator /= ( const char* ); sc_fix& operator /= ( const sc_fxval& ); sc_fix& operator /= ( const sc_fxval_fast& ); sc_fix& operator /= ( const sc_fxnum& ); sc_fix& operator /= ( const sc_fxnum_fast& ); sc_fix& operator /= ( int64 ); sc_fix& operator /= ( uint64 ); sc_fix& operator /= ( const sc_int_base& ); sc_fix& operator /= ( const sc_uint_base& ); sc_fix& operator /= ( const sc_signed& ); sc_fix& operator /= ( const sc_unsigned& );
    sc_fix& operator += ( int ); sc_fix& operator += ( unsigned int ); sc_fix& operator += ( long ); sc_fix& operator += ( unsigned long ); sc_fix& operator += ( double ); sc_fix& operator += ( const char* ); sc_fix& operator += ( const sc_fxval& ); sc_fix& operator += ( const sc_fxval_fast& ); sc_fix& operator += ( const sc_fxnum& ); sc_fix& operator += ( const sc_fxnum_fast& ); sc_fix& operator += ( int64 ); sc_fix& operator += ( uint64 ); sc_fix& operator += ( const sc_int_base& ); sc_fix& operator += ( const sc_uint_base& ); sc_fix& operator += ( const sc_signed& ); sc_fix& operator += ( const sc_unsigned& );
    sc_fix& operator -= ( int ); sc_fix& operator -= ( unsigned int ); sc_fix& operator -= ( long ); sc_fix& operator -= ( unsigned long ); sc_fix& operator -= ( double ); sc_fix& operator -= ( const char* ); sc_fix& operator -= ( const sc_fxval& ); sc_fix& operator -= ( const sc_fxval_fast& ); sc_fix& operator -= ( const sc_fxnum& ); sc_fix& operator -= ( const sc_fxnum_fast& ); sc_fix& operator -= ( int64 ); sc_fix& operator -= ( uint64 ); sc_fix& operator -= ( const sc_int_base& ); sc_fix& operator -= ( const sc_uint_base& ); sc_fix& operator -= ( const sc_signed& ); sc_fix& operator -= ( const sc_unsigned& );

    sc_fix& operator <<= ( int );
    sc_fix& operator >>= ( int );

    sc_fix& operator &= ( const sc_fix& );
    sc_fix& operator &= ( const sc_fix_fast& );
    sc_fix& operator |= ( const sc_fix& );
    sc_fix& operator |= ( const sc_fix_fast& );
    sc_fix& operator ^= ( const sc_fix& );
    sc_fix& operator ^= ( const sc_fix_fast& );
# 275 "../../../src/systemc/datatypes/fx/sc_fix.h"
    const sc_fxval operator ++ ( int );
    const sc_fxval operator -- ( int );

    sc_fix& operator ++ ();
    sc_fix& operator -- ();

};
# 290 "../../../src/systemc/datatypes/fx/sc_fix.h"
class sc_fix_fast : public sc_fxnum_fast
{

public:



    explicit sc_fix_fast( sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( sc_q_mode, sc_o_mode,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( sc_q_mode, sc_o_mode, int,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int, sc_q_mode, sc_o_mode,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int, sc_q_mode, sc_o_mode, int,
     sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( sc_q_mode, sc_o_mode,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( sc_q_mode, sc_o_mode, int,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int, sc_q_mode, sc_o_mode,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( int, int, sc_q_mode, sc_o_mode, int,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_fxtype_params&,
     sc_fxnum_fast_observer* = 0 );
             sc_fix_fast( const sc_fxtype_params&,
     const sc_fxcast_switch&,
     sc_fxnum_fast_observer* = 0 );
# 388 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix_fast( int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( unsigned int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned int, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( long, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( long, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( unsigned long, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( unsigned long, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( double, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( double, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( const char*, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const char*, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( const sc_fxval&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( const sc_fxval_fast&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxval_fast&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( const sc_fxnum&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fix_fast( const sc_fxnum_fast&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_fxnum_fast&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );

    explicit sc_fix_fast( int64, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( int64, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( uint64, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( uint64, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_int_base&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_int_base&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_uint_base&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_uint_base&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_signed&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_signed&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fix_fast( const sc_unsigned&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, int, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, int, int, sc_q_mode, sc_o_mode, int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, const sc_fxtype_params&, sc_fxnum_fast_observer* = 0 ); sc_fix_fast( const sc_unsigned&, const sc_fxtype_params&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
# 413 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix_fast( const sc_fix_fast& );




    const sc_fix_fast operator ~ () const;




    friend void b_not( sc_fix_fast&, const sc_fix_fast& );




    friend const sc_fix_fast operator & ( const sc_fix_fast&,
       const sc_fix_fast& );
    friend const sc_fix_fast operator ^ ( const sc_fix_fast&,
       const sc_fix_fast& );
    friend const sc_fix_fast operator | ( const sc_fix_fast&,
       const sc_fix_fast& );




    friend void b_and( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );
    friend void b_or ( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );
    friend void b_xor( sc_fix_fast&, const sc_fix_fast&, const sc_fix_fast& );




    sc_fix_fast& operator = ( const sc_fix_fast& );
# 475 "../../../src/systemc/datatypes/fx/sc_fix.h"
    sc_fix_fast& operator = ( int ); sc_fix_fast& operator = ( unsigned int ); sc_fix_fast& operator = ( long ); sc_fix_fast& operator = ( unsigned long ); sc_fix_fast& operator = ( double ); sc_fix_fast& operator = ( const char* ); sc_fix_fast& operator = ( const sc_fxval& ); sc_fix_fast& operator = ( const sc_fxval_fast& ); sc_fix_fast& operator = ( const sc_fxnum& ); sc_fix_fast& operator = ( const sc_fxnum_fast& ); sc_fix_fast& operator = ( int64 ); sc_fix_fast& operator = ( uint64 ); sc_fix_fast& operator = ( const sc_int_base& ); sc_fix_fast& operator = ( const sc_uint_base& ); sc_fix_fast& operator = ( const sc_signed& ); sc_fix_fast& operator = ( const sc_unsigned& );

    sc_fix_fast& operator *= ( int ); sc_fix_fast& operator *= ( unsigned int ); sc_fix_fast& operator *= ( long ); sc_fix_fast& operator *= ( unsigned long ); sc_fix_fast& operator *= ( double ); sc_fix_fast& operator *= ( const char* ); sc_fix_fast& operator *= ( const sc_fxval& ); sc_fix_fast& operator *= ( const sc_fxval_fast& ); sc_fix_fast& operator *= ( const sc_fxnum& ); sc_fix_fast& operator *= ( const sc_fxnum_fast& ); sc_fix_fast& operator *= ( int64 ); sc_fix_fast& operator *= ( uint64 ); sc_fix_fast& operator *= ( const sc_int_base& ); sc_fix_fast& operator *= ( const sc_uint_base& ); sc_fix_fast& operator *= ( const sc_signed& ); sc_fix_fast& operator *= ( const sc_unsigned& );
    sc_fix_fast& operator /= ( int ); sc_fix_fast& operator /= ( unsigned int ); sc_fix_fast& operator /= ( long ); sc_fix_fast& operator /= ( unsigned long ); sc_fix_fast& operator /= ( double ); sc_fix_fast& operator /= ( const char* ); sc_fix_fast& operator /= ( const sc_fxval& ); sc_fix_fast& operator /= ( const sc_fxval_fast& ); sc_fix_fast& operator /= ( const sc_fxnum& ); sc_fix_fast& operator /= ( const sc_fxnum_fast& ); sc_fix_fast& operator /= ( int64 ); sc_fix_fast& operator /= ( uint64 ); sc_fix_fast& operator /= ( const sc_int_base& ); sc_fix_fast& operator /= ( const sc_uint_base& ); sc_fix_fast& operator /= ( const sc_signed& ); sc_fix_fast& operator /= ( const sc_unsigned& );
    sc_fix_fast& operator += ( int ); sc_fix_fast& operator += ( unsigned int ); sc_fix_fast& operator += ( long ); sc_fix_fast& operator += ( unsigned long ); sc_fix_fast& operator += ( double ); sc_fix_fast& operator += ( const char* ); sc_fix_fast& operator += ( const sc_fxval& ); sc_fix_fast& operator += ( const sc_fxval_fast& ); sc_fix_fast& operator += ( const sc_fxnum& ); sc_fix_fast& operator += ( const sc_fxnum_fast& ); sc_fix_fast& operator += ( int64 ); sc_fix_fast& operator += ( uint64 ); sc_fix_fast& operator += ( const sc_int_base& ); sc_fix_fast& operator += ( const sc_uint_base& ); sc_fix_fast& operator += ( const sc_signed& ); sc_fix_fast& operator += ( const sc_unsigned& );
    sc_fix_fast& operator -= ( int ); sc_fix_fast& operator -= ( unsigned int ); sc_fix_fast& operator -= ( long ); sc_fix_fast& operator -= ( unsigned long ); sc_fix_fast& operator -= ( double ); sc_fix_fast& operator -= ( const char* ); sc_fix_fast& operator -= ( const sc_fxval& ); sc_fix_fast& operator -= ( const sc_fxval_fast& ); sc_fix_fast& operator -= ( const sc_fxnum& ); sc_fix_fast& operator -= ( const sc_fxnum_fast& ); sc_fix_fast& operator -= ( int64 ); sc_fix_fast& operator -= ( uint64 ); sc_fix_fast& operator -= ( const sc_int_base& ); sc_fix_fast& operator -= ( const sc_uint_base& ); sc_fix_fast& operator -= ( const sc_signed& ); sc_fix_fast& operator -= ( const sc_unsigned& );

    sc_fix_fast& operator <<= ( int );
    sc_fix_fast& operator >>= ( int );

    sc_fix_fast& operator &= ( const sc_fix& );
    sc_fix_fast& operator &= ( const sc_fix_fast& );
    sc_fix_fast& operator |= ( const sc_fix& );
    sc_fix_fast& operator |= ( const sc_fix_fast& );
    sc_fix_fast& operator ^= ( const sc_fix& );
    sc_fix_fast& operator ^= ( const sc_fix_fast& );
# 499 "../../../src/systemc/datatypes/fx/sc_fix.h"
    const sc_fxval_fast operator ++ ( int );
    const sc_fxval_fast operator -- ( int );

    sc_fix_fast& operator ++ ();
    sc_fix_fast& operator -- ();

};
# 518 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline
sc_fix::sc_fix( sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params(),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( qm, om ),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om, int nb,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( qm, om, nb ),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params(),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_ ),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( qm, om ),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( sc_q_mode qm, sc_o_mode om, int nb,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( qm, om, nb ),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om ),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
     SC_TC_,
     cast_sw,
     observer_ )
{}

inline
sc_fix::sc_fix( const sc_fxtype_params& type_params,
  sc_fxnum_observer* observer_ )
: sc_fxnum( type_params,
     SC_TC_,
     sc_fxcast_switch(),
     observer_ )
{}

inline
sc_fix::sc_fix( const sc_fxtype_params& type_params,
  const sc_fxcast_switch& cast_sw,
  sc_fxnum_observer* observer_ )
: sc_fxnum( type_params,
     SC_TC_,
     cast_sw,
     observer_ )
{}
# 969 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix::sc_fix( int a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( unsigned int a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned int a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned int a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( long a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( long a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( long a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( unsigned long a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( unsigned long a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( unsigned long a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( double a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( double a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( double a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const char* a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const char* a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const char* a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_fxval& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_fxval_fast& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxval_fast& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_fxnum& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, a.type_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, a.type_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_fxnum_fast& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, a.type_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, a.type_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_fxnum_fast& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}

inline sc_fix::sc_fix( int64 a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( int64 a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( int64 a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( uint64 a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( uint64 a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( uint64 a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_int_base& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_int_base& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_uint_base& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_uint_base& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_signed& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_signed& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix::sc_fix( const sc_unsigned& a, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, const sc_fxtype_params& type_params, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix::sc_fix( const sc_unsigned& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fxnum( a, type_params, SC_TC_, cast_sw, observer_ ) {}







inline
sc_fix::sc_fix( const sc_fix& a )
: sc_fxnum( a,
     a.type_params(),
     SC_TC_,
     sc_fxcast_switch(),
     0 )
{}




inline
const sc_fix
sc_fix::operator ~ () const
{
   
    int iwl_c = iwl();
    int wl_c = wl();
    sc_fix c( wl_c, iwl_c );
    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
 c.set_bit( i, ! get_bit( i ) );
    return sc_fix( c, wl_c, iwl_c );
}




inline
void
b_not( sc_fix& c, const sc_fix& a )
{
   
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
 c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
   
}
# 1053 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline const sc_fix operator & ( const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator & ( const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator & ( const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }

inline const sc_fix operator | ( const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator | ( const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator | ( const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }

inline const sc_fix operator ^ ( const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator ^ ( const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix operator ^ ( const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); return sc_fix( c, iwl_c + fwl_c, iwl_c ); }
# 1084 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline void b_and ( sc_fix& c, const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); c.cast(); }
inline void b_and ( sc_fix& c, const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); c.cast(); }
inline void b_and ( sc_fix& c, const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); c.cast(); }

inline void b_or ( sc_fix& c, const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); c.cast(); }
inline void b_or ( sc_fix& c, const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); c.cast(); }
inline void b_or ( sc_fix& c, const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); c.cast(); }

inline void b_xor ( sc_fix& c, const sc_fix& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); c.cast(); }
inline void b_xor ( sc_fix& c, const sc_fix& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); c.cast(); }
inline void b_xor ( sc_fix& c, const sc_fix_fast& a, const sc_fix& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); c.cast(); }






inline
sc_fix&
sc_fix::operator = ( const sc_fix& a )
{
    sc_fxnum::operator = ( a );
    return *this;
}
# 1143 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix& sc_fix::operator = ( int a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( unsigned int a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( long a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( unsigned long a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( double a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const char* a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_fxval& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_fxval_fast& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_fxnum& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_fxnum_fast& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( int64 a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( uint64 a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_int_base& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_uint_base& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_signed& a ) { sc_fxnum::operator =( a ); return *this; } inline sc_fix& sc_fix::operator = ( const sc_unsigned& a ) { sc_fxnum::operator =( a ); return *this; }

inline sc_fix& sc_fix::operator *= ( int a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( unsigned int a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( long a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( unsigned long a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( double a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const char* a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_fxval& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_fxval_fast& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_fxnum& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_fxnum_fast& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( int64 a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( uint64 a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_int_base& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_uint_base& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_signed& a ) { sc_fxnum::operator *=( a ); return *this; } inline sc_fix& sc_fix::operator *= ( const sc_unsigned& a ) { sc_fxnum::operator *=( a ); return *this; }
inline sc_fix& sc_fix::operator /= ( int a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( unsigned int a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( long a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( unsigned long a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( double a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const char* a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_fxval& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_fxval_fast& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_fxnum& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_fxnum_fast& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( int64 a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( uint64 a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_int_base& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_uint_base& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_signed& a ) { sc_fxnum::operator /=( a ); return *this; } inline sc_fix& sc_fix::operator /= ( const sc_unsigned& a ) { sc_fxnum::operator /=( a ); return *this; }
inline sc_fix& sc_fix::operator += ( int a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( unsigned int a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( long a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( unsigned long a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( double a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const char* a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_fxval& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_fxval_fast& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_fxnum& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_fxnum_fast& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( int64 a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( uint64 a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_int_base& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_uint_base& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_signed& a ) { sc_fxnum::operator +=( a ); return *this; } inline sc_fix& sc_fix::operator += ( const sc_unsigned& a ) { sc_fxnum::operator +=( a ); return *this; }
inline sc_fix& sc_fix::operator -= ( int a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( unsigned int a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( long a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( unsigned long a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( double a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const char* a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_fxval& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_fxval_fast& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_fxnum& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_fxnum_fast& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( int64 a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( uint64 a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_int_base& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_uint_base& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_signed& a ) { sc_fxnum::operator -=( a ); return *this; } inline sc_fix& sc_fix::operator -= ( const sc_unsigned& a ) { sc_fxnum::operator -=( a ); return *this; }

inline sc_fix& sc_fix::operator <<= ( int a ) { sc_fxnum::operator <<=( a ); return *this; }
inline sc_fix& sc_fix::operator >>= ( int a ) { sc_fxnum::operator >>=( a ); return *this; }
# 1173 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix& sc_fix::operator &= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) && b.get_bit( i ) ); cast(); return *this; }
inline sc_fix& sc_fix::operator &= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) && b.get_bit( i ) ); cast(); return *this; }
inline sc_fix& sc_fix::operator |= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) || b.get_bit( i ) ); cast(); return *this; }
inline sc_fix& sc_fix::operator |= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) || b.get_bit( i ) ); cast(); return *this; }
inline sc_fix& sc_fix::operator ^= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) != b.get_bit( i ) ); cast(); return *this; }
inline sc_fix& sc_fix::operator ^= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) != b.get_bit( i ) ); cast(); return *this; }






inline
const sc_fxval
sc_fix::operator ++ ( int )
{
    return sc_fxval( sc_fxnum::operator ++ ( 0 ) );
}

inline
const sc_fxval
sc_fix::operator -- ( int )
{
    return sc_fxval( sc_fxnum::operator -- ( 0 ) );
}

inline
sc_fix&
sc_fix::operator ++ ()
{
    sc_fxnum::operator ++ ();
    return *this;
}

inline
sc_fix&
sc_fix::operator -- ()
{
    sc_fxnum::operator -- ();
    return *this;
}
# 1224 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline
sc_fix_fast::sc_fix_fast( sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params(),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( qm, om ),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om, int nb,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
     sc_q_mode qm, sc_o_mode om, int nb,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params(),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_ ),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( qm, om ),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( sc_q_mode qm, sc_o_mode om, int nb,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( qm, om, nb ),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_, sc_q_mode qm, sc_o_mode om,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om ),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( int wl_, int iwl_,
     sc_q_mode qm, sc_o_mode om, int nb,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( sc_fxtype_params( wl_, iwl_, qm, om, nb ),
   SC_TC_,
   cast_sw,
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( const sc_fxtype_params& type_params,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( type_params,
   SC_TC_,
   sc_fxcast_switch(),
   observer_ )
{}

inline
sc_fix_fast::sc_fix_fast( const sc_fxtype_params& type_params,
     const sc_fxcast_switch& cast_sw,
     sc_fxnum_fast_observer* observer_ )
: sc_fxnum_fast( type_params,
   SC_TC_,
   cast_sw,
   observer_ )
{}
# 1681 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix_fast::sc_fix_fast( int a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( unsigned int a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned int a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( long a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( long a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( unsigned long a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( unsigned long a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( double a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( double a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const char* a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const char* a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxval_fast& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, a.type_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, a.type_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, a.type_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, a.type_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( a.type_params(), qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_fxnum_fast& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}

inline sc_fix_fast::sc_fix_fast( int64 a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( int64 a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( uint64 a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( uint64 a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_int_base& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_uint_base& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_signed& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_signed& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}
inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params(), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_ ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, int wl_, int iwl_, sc_q_mode qm, sc_o_mode om, int nb, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, sc_fxtype_params( wl_, iwl_, qm, om, nb ), SC_TC_, cast_sw, observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, const sc_fxtype_params& type_params, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, sc_fxcast_switch(), observer_ ) {} inline sc_fix_fast::sc_fix_fast( const sc_unsigned& a, const sc_fxtype_params& type_params, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fxnum_fast( a, type_params, SC_TC_, cast_sw, observer_ ) {}







inline
sc_fix_fast::sc_fix_fast( const sc_fix_fast& a )
: sc_fxnum_fast( a,
   a.type_params(),
   SC_TC_,
   sc_fxcast_switch(),
   0 )
{}




inline
const sc_fix_fast
sc_fix_fast::operator ~ () const
{
   
    int iwl_c = iwl();
    int wl_c = wl();
    sc_fix_fast c( wl_c, iwl_c );
    for( int i = iwl_c - wl_c; i < iwl_c; ++ i )
 c.set_bit( i, ! get_bit( i ) );
    return sc_fix_fast( c, wl_c, iwl_c );
}




inline
void
b_not( sc_fix_fast& c, const sc_fix_fast& a )
{
   
    int iwl_c = c.iwl();
    for( int i = iwl_c - c.wl(); i < iwl_c; ++ i )
 c.set_bit( i, ! a.get_bit( i ) );
    c.cast();
   
}
# 1765 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline const sc_fix_fast operator & ( const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix_fast c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); return sc_fix_fast( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix_fast operator | ( const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix_fast c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); return sc_fix_fast( c, iwl_c + fwl_c, iwl_c ); }
inline const sc_fix_fast operator ^ ( const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_a = a.iwl(); int iwl_b = b.iwl(); int iwl_c = sc_max( iwl_a, iwl_b ); int fwl_c = sc_max( a.wl() - iwl_a, b.wl() - iwl_b ); sc_fix_fast c( iwl_c + fwl_c, iwl_c ); for( int i = -fwl_c; i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); return sc_fix_fast( c, iwl_c + fwl_c, iwl_c ); }
# 1788 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline void b_and ( sc_fix_fast& c, const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) && b.get_bit( i ) ); c.cast(); }
inline void b_or ( sc_fix_fast& c, const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) || b.get_bit( i ) ); c.cast(); }
inline void b_xor ( sc_fix_fast& c, const sc_fix_fast& a, const sc_fix_fast& b ) { a.observer_read(); b.observer_read(); int iwl_c = c.iwl(); for( int i = iwl_c - c.wl(); i < iwl_c; ++ i ) c.set_bit( i, a.get_bit( i ) != b.get_bit( i ) ); c.cast(); }






inline
sc_fix_fast&
sc_fix_fast::operator = ( const sc_fix_fast& a )
{
    sc_fxnum_fast::operator = ( a );
    return *this;
}
# 1839 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix_fast& sc_fix_fast::operator = ( int a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( unsigned int a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( long a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( unsigned long a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( double a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const char* a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_fxval& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_fxval_fast& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_fxnum& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_fxnum_fast& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( int64 a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( uint64 a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_int_base& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_uint_base& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_signed& a ) { sc_fxnum_fast::operator =( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator = ( const sc_unsigned& a ) { sc_fxnum_fast::operator =( a ); return *this; }

inline sc_fix_fast& sc_fix_fast::operator *= ( int a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( unsigned int a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( long a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( unsigned long a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( double a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const char* a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_fxval& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_fxval_fast& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_fxnum& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_fxnum_fast& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( int64 a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( uint64 a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_int_base& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_uint_base& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_signed& a ) { sc_fxnum_fast::operator *=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator *= ( const sc_unsigned& a ) { sc_fxnum_fast::operator *=( a ); return *this; }
inline sc_fix_fast& sc_fix_fast::operator /= ( int a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( unsigned int a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( long a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( unsigned long a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( double a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const char* a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_fxval& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_fxval_fast& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_fxnum& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_fxnum_fast& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( int64 a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( uint64 a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_int_base& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_uint_base& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_signed& a ) { sc_fxnum_fast::operator /=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator /= ( const sc_unsigned& a ) { sc_fxnum_fast::operator /=( a ); return *this; }
inline sc_fix_fast& sc_fix_fast::operator += ( int a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( unsigned int a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( long a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( unsigned long a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( double a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const char* a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_fxval& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_fxval_fast& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_fxnum& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_fxnum_fast& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( int64 a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( uint64 a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_int_base& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_uint_base& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_signed& a ) { sc_fxnum_fast::operator +=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator += ( const sc_unsigned& a ) { sc_fxnum_fast::operator +=( a ); return *this; }
inline sc_fix_fast& sc_fix_fast::operator -= ( int a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( unsigned int a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( long a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( unsigned long a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( double a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const char* a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_fxval& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_fxval_fast& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_fxnum& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_fxnum_fast& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( int64 a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( uint64 a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_int_base& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_uint_base& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_signed& a ) { sc_fxnum_fast::operator -=( a ); return *this; } inline sc_fix_fast& sc_fix_fast::operator -= ( const sc_unsigned& a ) { sc_fxnum_fast::operator -=( a ); return *this; }

inline sc_fix_fast& sc_fix_fast::operator <<= ( int a ) { sc_fxnum_fast::operator <<=( a ); return *this; }
inline sc_fix_fast& sc_fix_fast::operator >>= ( int a ) { sc_fxnum_fast::operator >>=( a ); return *this; }
# 1869 "../../../src/systemc/datatypes/fx/sc_fix.h"
inline sc_fix_fast& sc_fix_fast::operator &= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) && b.get_bit( i ) ); cast(); return *this; }
inline sc_fix_fast& sc_fix_fast::operator &= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) && b.get_bit( i ) ); cast(); return *this; }
inline sc_fix_fast& sc_fix_fast::operator |= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) || b.get_bit( i ) ); cast(); return *this; }
inline sc_fix_fast& sc_fix_fast::operator |= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) || b.get_bit( i ) ); cast(); return *this; }
inline sc_fix_fast& sc_fix_fast::operator ^= ( const sc_fix& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) != b.get_bit( i ) ); cast(); return *this; }
inline sc_fix_fast& sc_fix_fast::operator ^= ( const sc_fix_fast& b ) { b.observer_read(); int iwl_c = iwl(); for( int i = iwl_c - wl(); i < iwl_c; ++ i ) set_bit( i, get_bit( i ) != b.get_bit( i ) ); cast(); return *this; }






inline
const sc_fxval_fast
sc_fix_fast::operator ++ ( int )
{
    return sc_fxval_fast( sc_fxnum_fast::operator ++ ( 0 ) );
}

inline
const sc_fxval_fast
sc_fix_fast::operator -- ( int )
{
    return sc_fxval_fast( sc_fxnum_fast::operator -- ( 0 ) );
}

inline
sc_fix_fast&
sc_fix_fast::operator ++ ()
{
    sc_fxnum_fast::operator ++ ();
    return *this;
}

inline
sc_fix_fast&
sc_fix_fast::operator -- ()
{
    sc_fxnum_fast::operator -- ();
    return *this;
}

}
# 41 "../../../src/systemc/datatypes/fx/sc_fixed.h" 2


namespace sc_dt
{


template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed;
template <int W, int I, sc_q_mode Q, sc_o_mode O, int N> class sc_fixed_fast;
# 57 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template <int W, int I,
   sc_q_mode Q = SC_DEFAULT_Q_MODE_,
   sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
class sc_fixed : public sc_fix
{

public:



    explicit sc_fixed( sc_fxnum_observer* = 0 );
    explicit sc_fixed( const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
# 78 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    sc_fixed( int, sc_fxnum_observer* = 0 ); sc_fixed( int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( unsigned int, sc_fxnum_observer* = 0 ); sc_fixed( unsigned int, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( long, sc_fxnum_observer* = 0 ); sc_fixed( long, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( unsigned long, sc_fxnum_observer* = 0 ); sc_fixed( unsigned long, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( double, sc_fxnum_observer* = 0 ); sc_fixed( double, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( const char*, sc_fxnum_observer* = 0 ); sc_fixed( const char*, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( const sc_fxval&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_fxval&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( const sc_fxval_fast&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_fxval_fast&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( const sc_fxnum&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_fxnum&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    sc_fixed( const sc_fxnum_fast&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_fxnum_fast&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );

    explicit sc_fixed( int64, sc_fxnum_observer* = 0 ); sc_fixed( int64, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fixed( uint64, sc_fxnum_observer* = 0 ); sc_fixed( uint64, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fixed( const sc_int_base&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_int_base&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fixed( const sc_uint_base&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_uint_base&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fixed( const sc_signed&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_signed&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );
    explicit sc_fixed( const sc_unsigned&, sc_fxnum_observer* = 0 ); sc_fixed( const sc_unsigned&, const sc_fxcast_switch&, sc_fxnum_observer* = 0 );







    sc_fixed( const sc_fixed<W,I,Q,O,N>& );




    sc_fixed& operator = ( const sc_fixed<W,I,Q,O,N>& );
# 137 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    sc_fixed& operator = ( int ); sc_fixed& operator = ( unsigned int ); sc_fixed& operator = ( long ); sc_fixed& operator = ( unsigned long ); sc_fixed& operator = ( double ); sc_fixed& operator = ( const char* ); sc_fixed& operator = ( const sc_fxval& ); sc_fixed& operator = ( const sc_fxval_fast& ); sc_fixed& operator = ( const sc_fxnum& ); sc_fixed& operator = ( const sc_fxnum_fast& ); sc_fixed& operator = ( int64 ); sc_fixed& operator = ( uint64 ); sc_fixed& operator = ( const sc_int_base& ); sc_fixed& operator = ( const sc_uint_base& ); sc_fixed& operator = ( const sc_signed& ); sc_fixed& operator = ( const sc_unsigned& );

    sc_fixed& operator *= ( int ); sc_fixed& operator *= ( unsigned int ); sc_fixed& operator *= ( long ); sc_fixed& operator *= ( unsigned long ); sc_fixed& operator *= ( double ); sc_fixed& operator *= ( const char* ); sc_fixed& operator *= ( const sc_fxval& ); sc_fixed& operator *= ( const sc_fxval_fast& ); sc_fixed& operator *= ( const sc_fxnum& ); sc_fixed& operator *= ( const sc_fxnum_fast& ); sc_fixed& operator *= ( int64 ); sc_fixed& operator *= ( uint64 ); sc_fixed& operator *= ( const sc_int_base& ); sc_fixed& operator *= ( const sc_uint_base& ); sc_fixed& operator *= ( const sc_signed& ); sc_fixed& operator *= ( const sc_unsigned& );
    sc_fixed& operator /= ( int ); sc_fixed& operator /= ( unsigned int ); sc_fixed& operator /= ( long ); sc_fixed& operator /= ( unsigned long ); sc_fixed& operator /= ( double ); sc_fixed& operator /= ( const char* ); sc_fixed& operator /= ( const sc_fxval& ); sc_fixed& operator /= ( const sc_fxval_fast& ); sc_fixed& operator /= ( const sc_fxnum& ); sc_fixed& operator /= ( const sc_fxnum_fast& ); sc_fixed& operator /= ( int64 ); sc_fixed& operator /= ( uint64 ); sc_fixed& operator /= ( const sc_int_base& ); sc_fixed& operator /= ( const sc_uint_base& ); sc_fixed& operator /= ( const sc_signed& ); sc_fixed& operator /= ( const sc_unsigned& );
    sc_fixed& operator += ( int ); sc_fixed& operator += ( unsigned int ); sc_fixed& operator += ( long ); sc_fixed& operator += ( unsigned long ); sc_fixed& operator += ( double ); sc_fixed& operator += ( const char* ); sc_fixed& operator += ( const sc_fxval& ); sc_fixed& operator += ( const sc_fxval_fast& ); sc_fixed& operator += ( const sc_fxnum& ); sc_fixed& operator += ( const sc_fxnum_fast& ); sc_fixed& operator += ( int64 ); sc_fixed& operator += ( uint64 ); sc_fixed& operator += ( const sc_int_base& ); sc_fixed& operator += ( const sc_uint_base& ); sc_fixed& operator += ( const sc_signed& ); sc_fixed& operator += ( const sc_unsigned& );
    sc_fixed& operator -= ( int ); sc_fixed& operator -= ( unsigned int ); sc_fixed& operator -= ( long ); sc_fixed& operator -= ( unsigned long ); sc_fixed& operator -= ( double ); sc_fixed& operator -= ( const char* ); sc_fixed& operator -= ( const sc_fxval& ); sc_fixed& operator -= ( const sc_fxval_fast& ); sc_fixed& operator -= ( const sc_fxnum& ); sc_fixed& operator -= ( const sc_fxnum_fast& ); sc_fixed& operator -= ( int64 ); sc_fixed& operator -= ( uint64 ); sc_fixed& operator -= ( const sc_int_base& ); sc_fixed& operator -= ( const sc_uint_base& ); sc_fixed& operator -= ( const sc_signed& ); sc_fixed& operator -= ( const sc_unsigned& );

    sc_fixed& operator <<= ( int );
    sc_fixed& operator >>= ( int );

    sc_fixed& operator &= ( const sc_fix& );
    sc_fixed& operator &= ( const sc_fix_fast& );
    sc_fixed& operator |= ( const sc_fix& );
    sc_fixed& operator |= ( const sc_fix_fast& );
    sc_fixed& operator ^= ( const sc_fix& );
    sc_fixed& operator ^= ( const sc_fix_fast& );
# 161 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    const sc_fxval operator ++ ( int );
    const sc_fxval operator -- ( int );

    sc_fixed& operator ++ ();
    sc_fixed& operator -- ();

};
# 176 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template <int W, int I,
   sc_q_mode Q = SC_DEFAULT_Q_MODE_,
   sc_o_mode O = SC_DEFAULT_O_MODE_, int N = SC_DEFAULT_N_BITS_>
class sc_fixed_fast : public sc_fix_fast
{

public:



    explicit sc_fixed_fast( sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( const sc_fxcast_switch&,
       sc_fxnum_fast_observer* = 0 );
# 200 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    sc_fixed_fast( int, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( unsigned int, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( unsigned int, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( long, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( long, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( unsigned long, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( unsigned long, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( double, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( double, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( const char*, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const char*, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( const sc_fxval&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_fxval&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( const sc_fxval_fast&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_fxval_fast&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( const sc_fxnum&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_fxnum&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    sc_fixed_fast( const sc_fxnum_fast&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_fxnum_fast&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );

    explicit sc_fixed_fast( int64, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( int64, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( uint64, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( uint64, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( const sc_int_base&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_int_base&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( const sc_uint_base&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_uint_base&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( const sc_signed&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_signed&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );
    explicit sc_fixed_fast( const sc_unsigned&, sc_fxnum_fast_observer* = 0 ); sc_fixed_fast( const sc_unsigned&, const sc_fxcast_switch&, sc_fxnum_fast_observer* = 0 );







    sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& );




    sc_fixed_fast& operator = ( const sc_fixed_fast<W,I,Q,O,N>& );
# 259 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    sc_fixed_fast& operator = ( int ); sc_fixed_fast& operator = ( unsigned int ); sc_fixed_fast& operator = ( long ); sc_fixed_fast& operator = ( unsigned long ); sc_fixed_fast& operator = ( double ); sc_fixed_fast& operator = ( const char* ); sc_fixed_fast& operator = ( const sc_fxval& ); sc_fixed_fast& operator = ( const sc_fxval_fast& ); sc_fixed_fast& operator = ( const sc_fxnum& ); sc_fixed_fast& operator = ( const sc_fxnum_fast& ); sc_fixed_fast& operator = ( int64 ); sc_fixed_fast& operator = ( uint64 ); sc_fixed_fast& operator = ( const sc_int_base& ); sc_fixed_fast& operator = ( const sc_uint_base& ); sc_fixed_fast& operator = ( const sc_signed& ); sc_fixed_fast& operator = ( const sc_unsigned& );

    sc_fixed_fast& operator *= ( int ); sc_fixed_fast& operator *= ( unsigned int ); sc_fixed_fast& operator *= ( long ); sc_fixed_fast& operator *= ( unsigned long ); sc_fixed_fast& operator *= ( double ); sc_fixed_fast& operator *= ( const char* ); sc_fixed_fast& operator *= ( const sc_fxval& ); sc_fixed_fast& operator *= ( const sc_fxval_fast& ); sc_fixed_fast& operator *= ( const sc_fxnum& ); sc_fixed_fast& operator *= ( const sc_fxnum_fast& ); sc_fixed_fast& operator *= ( int64 ); sc_fixed_fast& operator *= ( uint64 ); sc_fixed_fast& operator *= ( const sc_int_base& ); sc_fixed_fast& operator *= ( const sc_uint_base& ); sc_fixed_fast& operator *= ( const sc_signed& ); sc_fixed_fast& operator *= ( const sc_unsigned& );
    sc_fixed_fast& operator /= ( int ); sc_fixed_fast& operator /= ( unsigned int ); sc_fixed_fast& operator /= ( long ); sc_fixed_fast& operator /= ( unsigned long ); sc_fixed_fast& operator /= ( double ); sc_fixed_fast& operator /= ( const char* ); sc_fixed_fast& operator /= ( const sc_fxval& ); sc_fixed_fast& operator /= ( const sc_fxval_fast& ); sc_fixed_fast& operator /= ( const sc_fxnum& ); sc_fixed_fast& operator /= ( const sc_fxnum_fast& ); sc_fixed_fast& operator /= ( int64 ); sc_fixed_fast& operator /= ( uint64 ); sc_fixed_fast& operator /= ( const sc_int_base& ); sc_fixed_fast& operator /= ( const sc_uint_base& ); sc_fixed_fast& operator /= ( const sc_signed& ); sc_fixed_fast& operator /= ( const sc_unsigned& );
    sc_fixed_fast& operator += ( int ); sc_fixed_fast& operator += ( unsigned int ); sc_fixed_fast& operator += ( long ); sc_fixed_fast& operator += ( unsigned long ); sc_fixed_fast& operator += ( double ); sc_fixed_fast& operator += ( const char* ); sc_fixed_fast& operator += ( const sc_fxval& ); sc_fixed_fast& operator += ( const sc_fxval_fast& ); sc_fixed_fast& operator += ( const sc_fxnum& ); sc_fixed_fast& operator += ( const sc_fxnum_fast& ); sc_fixed_fast& operator += ( int64 ); sc_fixed_fast& operator += ( uint64 ); sc_fixed_fast& operator += ( const sc_int_base& ); sc_fixed_fast& operator += ( const sc_uint_base& ); sc_fixed_fast& operator += ( const sc_signed& ); sc_fixed_fast& operator += ( const sc_unsigned& );
    sc_fixed_fast& operator -= ( int ); sc_fixed_fast& operator -= ( unsigned int ); sc_fixed_fast& operator -= ( long ); sc_fixed_fast& operator -= ( unsigned long ); sc_fixed_fast& operator -= ( double ); sc_fixed_fast& operator -= ( const char* ); sc_fixed_fast& operator -= ( const sc_fxval& ); sc_fixed_fast& operator -= ( const sc_fxval_fast& ); sc_fixed_fast& operator -= ( const sc_fxnum& ); sc_fixed_fast& operator -= ( const sc_fxnum_fast& ); sc_fixed_fast& operator -= ( int64 ); sc_fixed_fast& operator -= ( uint64 ); sc_fixed_fast& operator -= ( const sc_int_base& ); sc_fixed_fast& operator -= ( const sc_uint_base& ); sc_fixed_fast& operator -= ( const sc_signed& ); sc_fixed_fast& operator -= ( const sc_unsigned& );

    sc_fixed_fast& operator <<= ( int );
    sc_fixed_fast& operator >>= ( int );

    sc_fixed_fast& operator &= ( const sc_fix& );
    sc_fixed_fast& operator &= ( const sc_fix_fast& );
    sc_fixed_fast& operator |= ( const sc_fix& );
    sc_fixed_fast& operator |= ( const sc_fix_fast& );
    sc_fixed_fast& operator ^= ( const sc_fix& );
    sc_fixed_fast& operator ^= ( const sc_fix_fast& );
# 283 "../../../src/systemc/datatypes/fx/sc_fixed.h"
    const sc_fxval_fast operator ++ ( int );
    const sc_fxval_fast operator -- ( int );

    sc_fixed_fast& operator ++ ();
    sc_fixed_fast& operator -- ();

};
# 300 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>::sc_fixed( sc_fxnum_observer* observer_ )
: sc_fix( W, I, Q, O, N, observer_ )
{}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxcast_switch& cast_sw,
          sc_fxnum_observer* observer_ )
: sc_fix( W, I, Q, O, N, cast_sw, observer_ )
{}
# 329 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( int a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( int a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( unsigned int a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( unsigned int a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( long a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( long a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( unsigned long a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( unsigned long a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( double a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( double a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const char* a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const char* a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxval& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxval& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxval_fast& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxval_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxnum& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxnum& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxnum_fast& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fxnum_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( int64 a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( int64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( uint64 a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( uint64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_int_base& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_int_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_uint_base& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_uint_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_signed& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_signed& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_unsigned& a, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_unsigned& a, const sc_fxcast_switch& cast_sw, sc_fxnum_observer* observer_ ) : sc_fix( a, W, I, Q, O, N, cast_sw, observer_ ) {}






template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>::sc_fixed( const sc_fixed<W,I,Q,O,N>& a )
: sc_fix( a, W, I, Q, O, N )
{}




template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator = ( const sc_fixed<W,I,Q,O,N>& a )
{
    sc_fix::operator = ( a );
    return *this;
}
# 405 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( int a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( unsigned int a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( long a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( unsigned long a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( double a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const char* a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_fxval& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_fxval_fast& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_fxnum& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_fxnum_fast& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( int64 a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( uint64 a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_int_base& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_uint_base& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_signed& a ) { sc_fix::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator = ( const sc_unsigned& a ) { sc_fix::operator = ( a ); return *this; }

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( int a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( unsigned int a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( long a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( unsigned long a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( double a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const char* a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_fxval& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_fxval_fast& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_fxnum& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_fxnum_fast& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( int64 a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( uint64 a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_int_base& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_uint_base& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_signed& a ) { sc_fix::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator *= ( const sc_unsigned& a ) { sc_fix::operator *= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( int a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( unsigned int a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( long a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( unsigned long a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( double a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const char* a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_fxval& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_fxval_fast& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_fxnum& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_fxnum_fast& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( int64 a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( uint64 a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_int_base& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_uint_base& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_signed& a ) { sc_fix::operator /= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator /= ( const sc_unsigned& a ) { sc_fix::operator /= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( int a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( unsigned int a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( long a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( unsigned long a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( double a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const char* a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_fxval& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_fxval_fast& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_fxnum& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_fxnum_fast& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( int64 a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( uint64 a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_int_base& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_uint_base& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_signed& a ) { sc_fix::operator += ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator += ( const sc_unsigned& a ) { sc_fix::operator += ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( int a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( unsigned int a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( long a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( unsigned long a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( double a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const char* a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_fxval& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_fxval_fast& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_fxnum& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_fxnum_fast& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( int64 a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( uint64 a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_int_base& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_uint_base& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_signed& a ) { sc_fix::operator -= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator -= ( const sc_unsigned& a ) { sc_fix::operator -= ( a ); return *this; }

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator <<= ( int a ) { sc_fix::operator <<= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator >>= ( int a ) { sc_fix::operator >>= ( a ); return *this; }

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator &= ( const sc_fix& a ) { sc_fix::operator &= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator &= ( const sc_fix_fast& a ) { sc_fix::operator &= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator |= ( const sc_fix& a ) { sc_fix::operator |= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator |= ( const sc_fix_fast& a ) { sc_fix::operator |= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator ^= ( const sc_fix& a ) { sc_fix::operator ^= ( a ); return *this; }
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed<W,I,Q,O,N>& sc_fixed<W,I,Q,O,N>::operator ^= ( const sc_fix_fast& a ) { sc_fix::operator ^= ( a ); return *this; }
# 429 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval
sc_fixed<W,I,Q,O,N>::operator ++ ( int )
{
    return sc_fxval( sc_fix::operator ++ ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
const sc_fxval
sc_fixed<W,I,Q,O,N>::operator -- ( int )
{
    return sc_fxval( sc_fix::operator -- ( 0 ) );
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator ++ ()
{
    sc_fix::operator ++ ();
    return *this;
}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed<W,I,Q,O,N>&
sc_fixed<W,I,Q,O,N>::operator -- ()
{
    sc_fix::operator -- ();
    return *this;
}
# 470 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( sc_fxnum_fast_observer* observer_ )
: sc_fix_fast( W, I, Q, O, N, observer_ )
{}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxcast_switch& cast_sw,
      sc_fxnum_fast_observer* observer_ )
: sc_fix_fast( W, I, Q, O, N, cast_sw, observer_ )
{}
# 499 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( int a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( int a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( unsigned int a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( unsigned int a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( long a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( long a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( unsigned long a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( unsigned long a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( double a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( double a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const char* a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const char* a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxval& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxval& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxval_fast& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxval_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxnum& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxnum& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxnum_fast& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fxnum_fast& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( int64 a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( int64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( uint64 a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( uint64 a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_int_base& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_int_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_uint_base& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_uint_base& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_signed& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_signed& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_unsigned& a, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, observer_ ) {} template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_unsigned& a, const sc_fxcast_switch& cast_sw, sc_fxnum_fast_observer* observer_ ) : sc_fix_fast( a, W, I, Q, O, N, cast_sw, observer_ ) {}






template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>::sc_fixed_fast( const sc_fixed_fast<W,I,Q,O,N>& a )
: sc_fix_fast( a, W, I, Q, O, N )
{}




template<int W, int I, sc_q_mode Q, sc_o_mode O, int N>
inline
sc_fixed_fast<W,I,Q,O,N>&
sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fixed_fast<W,I,Q,O,N>& a )
{
    sc_fix_fast::operator = ( a );
    return *this;
}
# 575 "../../../src/systemc/datatypes/fx/sc_fixed.h"
template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( int a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( unsigned int a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( long a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( unsigned long a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( double a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const char* a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fxval& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fxval_fast& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fxnum& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_fxnum_fast& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( int64 a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( uint64 a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_int_base& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_uint_base& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_signed& a ) { sc_fix_fast::operator = ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator = ( const sc_unsigned& a ) { sc_fix_fast::operator = ( a ); return *this; }

template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( int a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( unsigned int a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( long a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( unsigned long a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( double a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( const char* a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( const sc_fxval& a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( const sc_fxval_fast& a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I, sc_q_mode Q, sc_o_mode O, int N> inline sc_fixed_fast<W,I,Q,O,N>& sc_fixed_fast<W,I,Q,O,N>::operator *= ( const sc_fxnum& a ) { sc_fix_fast::operator *= ( a ); return *this; } template<int W, int I,